def _check_error_format(self, format: Optional[str] = None): check_error_format(format or self.FALLBACK_ERROR_FORMAT)
def add( # type: ignore self, uri: str, methods: Iterable[str], handler: RouteHandler, host: Optional[Union[str, Iterable[str]]] = None, strict_slashes: bool = False, stream: bool = False, ignore_body: bool = False, version: Union[str, float, int] = None, name: Optional[str] = None, unquote: bool = False, static: bool = False, version_prefix: str = "/v", error_format: Optional[str] = None, ) -> Union[Route, List[Route]]: """ Add a handler to the router :param uri: the path of the route :type uri: str :param methods: the types of HTTP methods that should be attached, example: ``["GET", "POST", "OPTIONS"]`` :type methods: Iterable[str] :param handler: the sync or async function to be executed :type handler: RouteHandler :param host: host that the route should be on, defaults to None :type host: Optional[str], optional :param strict_slashes: whether to apply strict slashes, defaults to False :type strict_slashes: bool, optional :param stream: whether to stream the response, defaults to False :type stream: bool, optional :param ignore_body: whether the incoming request body should be read, defaults to False :type ignore_body: bool, optional :param version: a version modifier for the uri, defaults to None :type version: Union[str, float, int], optional :param name: an identifying name of the route, defaults to None :type name: Optional[str], optional :return: the route object :rtype: Route """ if version is not None: version = str(version).strip("/").lstrip("v") uri = "/".join([f"{version_prefix}{version}", uri.lstrip("/")]) uri = self._normalize(uri, handler) params = dict( path=uri, handler=handler, methods=frozenset(map(str, methods)) if methods else None, name=name, strict=strict_slashes, unquote=unquote, ) if isinstance(host, str): hosts = [host] else: hosts = host or [None] # type: ignore routes = [] for host in hosts: if host: params.update({"requirements": {"host": host}}) route = super().add(**params) # type: ignore route.ctx.ignore_body = ignore_body route.ctx.stream = stream route.ctx.hosts = hosts route.ctx.static = static route.ctx.error_format = ( error_format or self.ctx.app.config.FALLBACK_ERROR_FORMAT) check_error_format(route.ctx.error_format) routes.append(route) if len(routes) == 1: return routes[0] return routes
def _check_error_format(self): check_error_format(self.FALLBACK_ERROR_FORMAT)