Coverage for /pythoncovmergedfiles/medio/medio/src/aiohttp/aiohttp/web_routedef.py: 57%

1import abc 

2import dataclasses 

3import os # noqa 

4from typing import ( 

5 TYPE_CHECKING, 

6 Any, 

7 Callable, 

8 Dict, 

9 Iterator, 

10 List, 

11 Optional, 

12 Sequence, 

13 Type, 

14 Union, 

15 overload, 

16) 

17 

18from . import hdrs 

19from .abc import AbstractView 

20from .typedefs import Handler, PathLike 

21 

22if TYPE_CHECKING: # pragma: no cover 

23 from .web_request import Request 

24 from .web_response import StreamResponse 

25 from .web_urldispatcher import AbstractRoute, UrlDispatcher 

26else: 

27 Request = StreamResponse = UrlDispatcher = AbstractRoute = None 

28 

29 

30__all__ = ( 

31 "AbstractRouteDef", 

32 "RouteDef", 

33 "StaticDef", 

34 "RouteTableDef", 

35 "head", 

36 "options", 

37 "get", 

38 "post", 

39 "patch", 

40 "put", 

41 "delete", 

42 "route", 

43 "view", 

44 "static", 

45) 

46 

47 

48class AbstractRouteDef(abc.ABC): 

49 @abc.abstractmethod 

50 def register(self, router: UrlDispatcher) -> List[AbstractRoute]: 

51 pass # pragma: no cover 

52 

53 

54_HandlerType = Union[Type[AbstractView], Handler] 

55 

56 

57@dataclasses.dataclass(frozen=True, repr=False) 

58class RouteDef(AbstractRouteDef): 

59 method: str 

60 path: str 

61 handler: _HandlerType 

62 kwargs: Dict[str, Any] 

63 

64 def __repr__(self) -> str: 

65 info = [] 

66 for name, value in sorted(self.kwargs.items()): 

67 info.append(f", {name}={value!r}") 

68 return "<RouteDef {method} {path} -> {handler.__name__!r}" "{info}>".format( 

69 method=self.method, path=self.path, handler=self.handler, info="".join(info) 

70 ) 

71 

72 def register(self, router: UrlDispatcher) -> List[AbstractRoute]: 

73 if self.method in hdrs.METH_ALL: 

74 reg = getattr(router, "add_" + self.method.lower()) 

75 return [reg(self.path, self.handler, **self.kwargs)] 

76 else: 

77 return [ 

78 router.add_route(self.method, self.path, self.handler, **self.kwargs) 

79 ] 

80 

81 

82@dataclasses.dataclass(frozen=True, repr=False) 

83class StaticDef(AbstractRouteDef): 

84 prefix: str 

85 path: PathLike 

86 kwargs: Dict[str, Any] 

87 

88 def __repr__(self) -> str: 

89 info = [] 

90 for name, value in sorted(self.kwargs.items()): 

91 info.append(f", {name}={value!r}") 

92 return "<StaticDef {prefix} -> {path}" "{info}>".format( 

93 prefix=self.prefix, path=self.path, info="".join(info) 

94 ) 

95 

96 def register(self, router: UrlDispatcher) -> List[AbstractRoute]: 

97 resource = router.add_static(self.prefix, self.path, **self.kwargs) 

98 routes = resource.get_info().get("routes", {}) 

99 return list(routes.values()) 

100 

101 

102def route(method: str, path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef: 

103 return RouteDef(method, path, handler, kwargs) 

104 

105 

106def head(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef: 

107 return route(hdrs.METH_HEAD, path, handler, **kwargs) 

108 

109 

110def options(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef: 

111 return route(hdrs.METH_OPTIONS, path, handler, **kwargs) 

112 

113 

114def get( 

115 path: str, 

116 handler: _HandlerType, 

117 *, 

118 name: Optional[str] = None, 

119 allow_head: bool = True, 

120 **kwargs: Any, 

121) -> RouteDef: 

122 return route( 

123 hdrs.METH_GET, path, handler, name=name, allow_head=allow_head, **kwargs 

124 ) 

125 

126 

127def post(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef: 

128 return route(hdrs.METH_POST, path, handler, **kwargs) 

129 

130 

131def put(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef: 

132 return route(hdrs.METH_PUT, path, handler, **kwargs) 

133 

134 

135def patch(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef: 

136 return route(hdrs.METH_PATCH, path, handler, **kwargs) 

137 

138 

139def delete(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef: 

140 return route(hdrs.METH_DELETE, path, handler, **kwargs) 

141 

142 

143def view(path: str, handler: Type[AbstractView], **kwargs: Any) -> RouteDef: 

144 return route(hdrs.METH_ANY, path, handler, **kwargs) 

145 

146 

147def static(prefix: str, path: PathLike, **kwargs: Any) -> StaticDef: 

148 return StaticDef(prefix, path, kwargs) 

149 

150 

151_Deco = Callable[[_HandlerType], _HandlerType] 

152 

153 

154class RouteTableDef(Sequence[AbstractRouteDef]): 

155 """Route definition table""" 

156 

157 def __init__(self) -> None: 

158 self._items: List[AbstractRouteDef] = [] 

159 

160 def __repr__(self) -> str: 

161 return f"<RouteTableDef count={len(self._items)}>" 

162 

163 @overload 

164 def __getitem__(self, index: int) -> AbstractRouteDef: 

165 ... 

166 

167 @overload 

168 def __getitem__(self, index: slice) -> List[AbstractRouteDef]: 

169 ... 

170 

171 def __getitem__(self, index): # type: ignore[no-untyped-def] 

172 return self._items[index] 

173 

174 def __iter__(self) -> Iterator[AbstractRouteDef]: 

175 return iter(self._items) 

176 

177 def __len__(self) -> int: 

178 return len(self._items) 

179 

180 def __contains__(self, item: object) -> bool: 

181 return item in self._items 

182 

183 def route(self, method: str, path: str, **kwargs: Any) -> _Deco: 

184 def inner(handler: _HandlerType) -> _HandlerType: 

185 self._items.append(RouteDef(method, path, handler, kwargs)) 

186 return handler 

187 

188 return inner 

189 

190 def head(self, path: str, **kwargs: Any) -> _Deco: 

191 return self.route(hdrs.METH_HEAD, path, **kwargs) 

192 

193 def get(self, path: str, **kwargs: Any) -> _Deco: 

194 return self.route(hdrs.METH_GET, path, **kwargs) 

195 

196 def post(self, path: str, **kwargs: Any) -> _Deco: 

197 return self.route(hdrs.METH_POST, path, **kwargs) 

198 

199 def put(self, path: str, **kwargs: Any) -> _Deco: 

200 return self.route(hdrs.METH_PUT, path, **kwargs) 

201 

202 def patch(self, path: str, **kwargs: Any) -> _Deco: 

203 return self.route(hdrs.METH_PATCH, path, **kwargs) 

204 

205 def delete(self, path: str, **kwargs: Any) -> _Deco: 

206 return self.route(hdrs.METH_DELETE, path, **kwargs) 

207 

208 def options(self, path: str, **kwargs: Any) -> _Deco: 

209 return self.route(hdrs.METH_OPTIONS, path, **kwargs) 

210 

211 def view(self, path: str, **kwargs: Any) -> _Deco: 

212 return self.route(hdrs.METH_ANY, path, **kwargs) 

213 

214 def static(self, prefix: str, path: PathLike, **kwargs: Any) -> None: 

215 self._items.append(StaticDef(prefix, path, kwargs))