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

1import abc 

2import dataclasses 

3from typing import ( 

4 TYPE_CHECKING, 

5 Any, 

6 Callable, 

7 Dict, 

8 Iterator, 

9 List, 

10 Optional, 

11 Sequence, 

12 Type, 

13 Union, 

14 overload, 

15) 

16 

17from . import hdrs 

18from .abc import AbstractView 

19from .typedefs import Handler, PathLike 

20 

21if TYPE_CHECKING: 

22 from .web_request import Request 

23 from .web_response import StreamResponse 

24 from .web_urldispatcher import AbstractRoute, UrlDispatcher 

25else: 

26 Request = StreamResponse = UrlDispatcher = AbstractRoute = None 

27 

28 

29__all__ = ( 

30 "AbstractRouteDef", 

31 "RouteDef", 

32 "StaticDef", 

33 "RouteTableDef", 

34 "head", 

35 "options", 

36 "get", 

37 "post", 

38 "patch", 

39 "put", 

40 "delete", 

41 "route", 

42 "view", 

43 "static", 

44) 

45 

46 

47class AbstractRouteDef(abc.ABC): 

48 @abc.abstractmethod 

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

50 """Register itself into the given router.""" 

51 

52 

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

54 

55 

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

57class RouteDef(AbstractRouteDef): # type: ignore[misc] 

58 method: str 

59 path: str 

60 handler: _HandlerType 

61 kwargs: Dict[str, Any] 

62 

63 def __repr__(self) -> str: 

64 info = [] 

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

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

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

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

69 ) 

70 

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

72 if self.method in hdrs.METH_ALL: 

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

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

75 else: 

76 return [ 

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

78 ] 

79 

80 

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

82class StaticDef(AbstractRouteDef): # type: ignore[misc] 

83 prefix: str 

84 path: PathLike 

85 kwargs: Dict[str, Any] 

86 

87 def __repr__(self) -> str: 

88 info = [] 

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

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

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

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

93 ) 

94 

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

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

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

98 return list(routes.values()) 

99 

100 

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

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

103 

104 

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

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

107 

108 

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

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

111 

112 

113def get( 

114 path: str, 

115 handler: _HandlerType, 

116 *, 

117 name: Optional[str] = None, 

118 allow_head: bool = True, 

119 **kwargs: Any, 

120) -> RouteDef: 

121 return route( 

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

123 ) 

124 

125 

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

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

128 

129 

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

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

132 

133 

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

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

136 

137 

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

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

140 

141 

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

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

144 

145 

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

147 return StaticDef(prefix, path, kwargs) 

148 

149 

150_Deco = Callable[[_HandlerType], _HandlerType] 

151 

152 

153class RouteTableDef(Sequence[AbstractRouteDef]): 

154 """Route definition table""" 

155 

156 def __init__(self) -> None: 

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

158 

159 def __repr__(self) -> str: 

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

161 

162 @overload 

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

164 

165 @overload 

166 def __getitem__(self, index: "slice[int, int, int]") -> List[AbstractRouteDef]: ... 

167 

168 def __getitem__( 

169 self, index: Union[int, "slice[int, int, int]"] 

170 ) -> Union[AbstractRouteDef, List[AbstractRouteDef]]: 

171 return self._items[index] 

172 

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

174 return iter(self._items) 

175 

176 def __len__(self) -> int: 

177 return len(self._items) 

178 

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

180 return item in self._items 

181 

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

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

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

185 return handler 

186 

187 return inner 

188 

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

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

191 

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

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

194 

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

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

197 

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

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

200 

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

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

203 

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

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

206 

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

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

209 

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

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

212 

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

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