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

1import abc 

2import dataclasses 

3from collections.abc import Callable, Iterator, Sequence 

4from typing import TYPE_CHECKING, Any, Union, overload 

5 

6from . import hdrs 

7from .abc import AbstractView 

8from .typedefs import Handler, PathLike 

9 

10if TYPE_CHECKING: 

11 from .web_request import Request 

12 from .web_response import StreamResponse 

13 from .web_urldispatcher import AbstractRoute, UrlDispatcher 

14else: 

15 Request = StreamResponse = UrlDispatcher = AbstractRoute = None 

16 

17 

18__all__ = ( 

19 "AbstractRouteDef", 

20 "RouteDef", 

21 "StaticDef", 

22 "RouteTableDef", 

23 "head", 

24 "options", 

25 "get", 

26 "post", 

27 "patch", 

28 "put", 

29 "delete", 

30 "route", 

31 "view", 

32 "static", 

33) 

34 

35 

36class AbstractRouteDef(abc.ABC): 

37 @abc.abstractmethod 

38 def register(self, router: UrlDispatcher) -> list[AbstractRoute]: 

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

40 

41 

42_HandlerType = Union[type[AbstractView], Handler] 

43 

44 

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

46class RouteDef(AbstractRouteDef): 

47 method: str 

48 path: str 

49 handler: _HandlerType 

50 kwargs: dict[str, Any] 

51 

52 def __repr__(self) -> str: 

53 info = [] 

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

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

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

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

58 ) 

59 

60 def register(self, router: UrlDispatcher) -> list[AbstractRoute]: 

61 if self.method in hdrs.METH_ALL: 

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

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

64 else: 

65 return [ 

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

67 ] 

68 

69 

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

71class StaticDef(AbstractRouteDef): 

72 prefix: str 

73 path: PathLike 

74 kwargs: dict[str, Any] 

75 

76 def __repr__(self) -> str: 

77 info = [] 

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

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

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

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

82 ) 

83 

84 def register(self, router: UrlDispatcher) -> list[AbstractRoute]: 

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

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

87 return list(routes.values()) 

88 

89 

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

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

92 

93 

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

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

96 

97 

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

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

100 

101 

102def get( 

103 path: str, 

104 handler: _HandlerType, 

105 *, 

106 name: str | None = None, 

107 allow_head: bool = True, 

108 **kwargs: Any, 

109) -> RouteDef: 

110 return route( 

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

112 ) 

113 

114 

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

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

117 

118 

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

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

121 

122 

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

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

125 

126 

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

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

129 

130 

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

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

133 

134 

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

136 return StaticDef(prefix, path, kwargs) 

137 

138 

139_Deco = Callable[[_HandlerType], _HandlerType] 

140 

141 

142class RouteTableDef(Sequence[AbstractRouteDef]): 

143 """Route definition table""" 

144 

145 def __init__(self) -> None: 

146 self._items: list[AbstractRouteDef] = [] 

147 

148 def __repr__(self) -> str: 

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

150 

151 @overload 

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

153 

154 @overload 

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

156 

157 def __getitem__( 

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

159 ) -> AbstractRouteDef | list[AbstractRouteDef]: 

160 return self._items[index] 

161 

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

163 return iter(self._items) 

164 

165 def __len__(self) -> int: 

166 return len(self._items) 

167 

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

169 return item in self._items 

170 

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

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

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

174 return handler 

175 

176 return inner 

177 

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

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

180 

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

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

183 

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

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

186 

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

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

189 

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

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

192 

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

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

195 

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

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

198 

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

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

201 

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

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