def resolve(self, parameter: Parameter) -> Any:
try:
return parameter.annotation(self.params[parameter.name])
except (TypeError, ValueError):
raise HTTPError(
HTTP_400, {
"errors": {
parameter.name:
f"invalid {parameter.annotation.__name__} value",
}
})
def resolve(parameter: Parameter, params_dict):
try:
value = params_dict[parameter.name]
except KeyError:
if parameter.default is not parameter.empty:
return parameter.default
else:
raise exceptions.NotFound(
f"Parameter {parameter.name} not resolved")
try:
return parameter.annotation(value)
except Exception:
raise exceptions.BadRequest(f"Parameter {parameter.name} invalid")
def _convertArgs(name: str, param: inspect.Parameter, arg: str):
Logger.verbose(f"Transforming Argument Data For Argument {name}",
module="command")
# If There Is No Type To Convert, Ignore
if param.annotation == inspect._empty: # type: ignore
return arg
# Try to parse, if error, cancel
try:
return param.annotation(arg)
except ValueError:
raise CommandError(
f"Argument '{name}' Expected {param.annotation.__name__} But Got '{type(arg).__name__}'"
)
def resolve(self, route: Route, data: http.RequestData,
parameter: inspect.Parameter, query_params: http.QueryParams):
data = data or query_params
if not data:
if parameter.default != inspect._empty:
data = parameter.default
else:
raise BadRequest(f"{parameter.name} cannot be empty!")
if isinstance(data, ImmutableMultiDict):
data = self._change_to_dict(data)
try:
return parameter.annotation(data)
except Exception:
return data
def resolve(self, parameter: inspect.Parameter,
data: ValidatedRequestData):
try:
return parameter.annotation(data)
except validators.ValidationError as exc:
raise exceptions.BadRequest(exc.detail)
def resolve(self,
parameter: inspect.Parameter,
data: ValidatedRequestData):
return parameter.annotation(data)
def handle_parameter(self, parameter: Parameter, value_dict):
return parameter.annotation(value_dict)
