| import difflib |
| import typing as t |
|
|
| from ..exceptions import BadRequest |
| from ..exceptions import HTTPException |
| from ..utils import cached_property |
| from ..utils import redirect |
|
|
| if t.TYPE_CHECKING: |
| from _typeshed.wsgi import WSGIEnvironment |
| from .map import MapAdapter |
| from .rules import Rule |
| from ..wrappers.request import Request |
| from ..wrappers.response import Response |
|
|
|
|
| class RoutingException(Exception): |
| """Special exceptions that require the application to redirect, notifying |
| about missing urls, etc. |
| |
| :internal: |
| """ |
|
|
|
|
| class RequestRedirect(HTTPException, RoutingException): |
| """Raise if the map requests a redirect. This is for example the case if |
| `strict_slashes` are activated and an url that requires a trailing slash. |
| |
| The attribute `new_url` contains the absolute destination url. |
| """ |
|
|
| code = 308 |
|
|
| def __init__(self, new_url: str) -> None: |
| super().__init__(new_url) |
| self.new_url = new_url |
|
|
| def get_response( |
| self, |
| environ: t.Optional[t.Union["WSGIEnvironment", "Request"]] = None, |
| scope: t.Optional[dict] = None, |
| ) -> "Response": |
| return redirect(self.new_url, self.code) |
|
|
|
|
| class RequestPath(RoutingException): |
| """Internal exception.""" |
|
|
| __slots__ = ("path_info",) |
|
|
| def __init__(self, path_info: str) -> None: |
| super().__init__() |
| self.path_info = path_info |
|
|
|
|
| class RequestAliasRedirect(RoutingException): |
| """This rule is an alias and wants to redirect to the canonical URL.""" |
|
|
| def __init__(self, matched_values: t.Mapping[str, t.Any], endpoint: str) -> None: |
| super().__init__() |
| self.matched_values = matched_values |
| self.endpoint = endpoint |
|
|
|
|
| class BuildError(RoutingException, LookupError): |
| """Raised if the build system cannot find a URL for an endpoint with the |
| values provided. |
| """ |
|
|
| def __init__( |
| self, |
| endpoint: str, |
| values: t.Mapping[str, t.Any], |
| method: t.Optional[str], |
| adapter: t.Optional["MapAdapter"] = None, |
| ) -> None: |
| super().__init__(endpoint, values, method) |
| self.endpoint = endpoint |
| self.values = values |
| self.method = method |
| self.adapter = adapter |
|
|
| @cached_property |
| def suggested(self) -> t.Optional["Rule"]: |
| return self.closest_rule(self.adapter) |
|
|
| def closest_rule(self, adapter: t.Optional["MapAdapter"]) -> t.Optional["Rule"]: |
| def _score_rule(rule: "Rule") -> float: |
| return sum( |
| [ |
| 0.98 |
| * difflib.SequenceMatcher( |
| None, rule.endpoint, self.endpoint |
| ).ratio(), |
| 0.01 * bool(set(self.values or ()).issubset(rule.arguments)), |
| 0.01 * bool(rule.methods and self.method in rule.methods), |
| ] |
| ) |
|
|
| if adapter and adapter.map._rules: |
| return max(adapter.map._rules, key=_score_rule) |
|
|
| return None |
|
|
| def __str__(self) -> str: |
| message = [f"Could not build url for endpoint {self.endpoint!r}"] |
| if self.method: |
| message.append(f" ({self.method!r})") |
| if self.values: |
| message.append(f" with values {sorted(self.values)!r}") |
| message.append(".") |
| if self.suggested: |
| if self.endpoint == self.suggested.endpoint: |
| if ( |
| self.method |
| and self.suggested.methods is not None |
| and self.method not in self.suggested.methods |
| ): |
| message.append( |
| " Did you mean to use methods" |
| f" {sorted(self.suggested.methods)!r}?" |
| ) |
| missing_values = self.suggested.arguments.union( |
| set(self.suggested.defaults or ()) |
| ) - set(self.values.keys()) |
| if missing_values: |
| message.append( |
| f" Did you forget to specify values {sorted(missing_values)!r}?" |
| ) |
| else: |
| message.append(f" Did you mean {self.suggested.endpoint!r} instead?") |
| return "".join(message) |
|
|
|
|
| class WebsocketMismatch(BadRequest): |
| """The only matched rule is either a WebSocket and the request is |
| HTTP, or the rule is HTTP and the request is a WebSocket. |
| """ |
|
|
|
|
| class NoMatch(Exception): |
| __slots__ = ("have_match_for", "websocket_mismatch") |
|
|
| def __init__(self, have_match_for: t.Set[str], websocket_mismatch: bool) -> None: |
| self.have_match_for = have_match_for |
| self.websocket_mismatch = websocket_mismatch |
|
|
