def resolve(self, parameter: inspect.Parameter,
path_params: ValidatedPathParams,
query_params: ValidatedQueryParams):
params = path_params if (parameter.name
in path_params) else query_params
has_default = parameter.default is not parameter.empty
allow_null = parameter.default is None
param_validator = {
parameter.empty: validators.Any(),
str: validators.String(allow_null=allow_null),
int: validators.Integer(allow_null=allow_null),
float: validators.Number(allow_null=allow_null),
bool: validators.Boolean(allow_null=allow_null)
}[parameter.annotation]
validator = validators.Object(
properties=[(parameter.name, param_validator)],
required=[] if has_default else [parameter.name])
try:
params = validator.validate(params, allow_coerce=True)
except validators.ValidationError as exc:
raise exceptions.NotFound(exc.detail)
return params.get(parameter.name, parameter.default)
def resolve(self, route: Route,
path_params: http.PathParams) -> ValidatedPathParams:
path_fields = route.link.get_path_fields()
validator = validators.Object(
properties=[(field.name,
field.schema if field.schema else validators.Any())
for field in path_fields],
required=[field.name for field in path_fields])
try:
path_params = validator.validate(path_params, allow_coerce=True)
except validators.ValidationError as exc:
raise exceptions.NotFound(exc.detail)
return ValidatedPathParams(path_params)
def lookup(self, path: str, method: str):
lookup_key = method + ' ' + path
try:
return self._lookup_cache[lookup_key]
except KeyError:
pass
try:
name, path_params = self.adapter.match(path, method)
except werkzeug.exceptions.NotFound:
raise exceptions.NotFound() from None
except werkzeug.exceptions.MethodNotAllowed:
raise exceptions.MethodNotAllowed() from None
except werkzeug.routing.RequestRedirect as exc:
path = urlparse(exc.new_url).path
raise exceptions.Found(path) from None
route = self.name_lookups[name]
self._lookup_cache[lookup_key] = (route, path_params)
if len(self._lookup_cache) > self._lookup_cache_size:
self._lookup_cache.pop(next(iter(self._lookup_cache)))
return (route, path_params)
async def not_found(receive, send):
raise exceptions.NotFound()
def not_found(self, environ, start_response):
raise exceptions.NotFound()