Intelegentny_Pszczelarz/.venv/Lib/site-packages/werkzeug/routing/matcher.py

203 lines
7.6 KiB
Python
Raw Normal View History

2023-06-19 00:49:18 +02:00
from __future__ import annotations
import re
import typing as t
from dataclasses import dataclass
from dataclasses import field
from .converters import ValidationError
from .exceptions import NoMatch
from .exceptions import RequestAliasRedirect
from .exceptions import RequestPath
from .rules import Rule
from .rules import RulePart
class SlashRequired(Exception):
pass
@dataclass
class State:
"""A representation of a rule state.
This includes the *rules* that correspond to the state and the
possible *static* and *dynamic* transitions to the next state.
"""
dynamic: list[tuple[RulePart, State]] = field(default_factory=list)
rules: list[Rule] = field(default_factory=list)
static: dict[str, State] = field(default_factory=dict)
class StateMachineMatcher:
def __init__(self, merge_slashes: bool) -> None:
self._root = State()
self.merge_slashes = merge_slashes
def add(self, rule: Rule) -> None:
state = self._root
for part in rule._parts:
if part.static:
state.static.setdefault(part.content, State())
state = state.static[part.content]
else:
for test_part, new_state in state.dynamic:
if test_part == part:
state = new_state
break
else:
new_state = State()
state.dynamic.append((part, new_state))
state = new_state
state.rules.append(rule)
def update(self) -> None:
# For every state the dynamic transitions should be sorted by
# the weight of the transition
state = self._root
def _update_state(state: State) -> None:
state.dynamic.sort(key=lambda entry: entry[0].weight)
for new_state in state.static.values():
_update_state(new_state)
for _, new_state in state.dynamic:
_update_state(new_state)
_update_state(state)
def match(
self, domain: str, path: str, method: str, websocket: bool
) -> tuple[Rule, t.MutableMapping[str, t.Any]]:
# To match to a rule we need to start at the root state and
# try to follow the transitions until we find a match, or find
# there is no transition to follow.
have_match_for = set()
websocket_mismatch = False
def _match(
state: State, parts: list[str], values: list[str]
) -> tuple[Rule, list[str]] | None:
# This function is meant to be called recursively, and will attempt
# to match the head part to the state's transitions.
nonlocal have_match_for, websocket_mismatch
# The base case is when all parts have been matched via
# transitions. Hence if there is a rule with methods &
# websocket that work return it and the dynamic values
# extracted.
if parts == []:
for rule in state.rules:
if rule.methods is not None and method not in rule.methods:
have_match_for.update(rule.methods)
elif rule.websocket != websocket:
websocket_mismatch = True
else:
return rule, values
# Test if there is a match with this path with a
# trailing slash, if so raise an exception to report
# that matching is possible with an additional slash
if "" in state.static:
for rule in state.static[""].rules:
if websocket == rule.websocket and (
rule.methods is None or method in rule.methods
):
if rule.strict_slashes:
raise SlashRequired()
else:
return rule, values
return None
part = parts[0]
# To match this part try the static transitions first
if part in state.static:
rv = _match(state.static[part], parts[1:], values)
if rv is not None:
return rv
# No match via the static transitions, so try the dynamic
# ones.
for test_part, new_state in state.dynamic:
target = part
remaining = parts[1:]
# A final part indicates a transition that always
# consumes the remaining parts i.e. transitions to a
# final state.
if test_part.final:
target = "/".join(parts)
remaining = []
match = re.compile(test_part.content).match(target)
if match is not None:
if test_part.suffixed:
# If a part_isolating=False part has a slash suffix, remove the
# suffix from the match and check for the slash redirect next.
suffix = match.groups()[-1]
if suffix == "/":
remaining = [""]
converter_groups = sorted(
match.groupdict().items(), key=lambda entry: entry[0]
)
groups = [
value
for key, value in converter_groups
if key[:11] == "__werkzeug_"
]
rv = _match(new_state, remaining, values + groups)
if rv is not None:
return rv
# If there is no match and the only part left is a
# trailing slash ("") consider rules that aren't
# strict-slashes as these should match if there is a final
# slash part.
if parts == [""]:
for rule in state.rules:
if rule.strict_slashes:
continue
if rule.methods is not None and method not in rule.methods:
have_match_for.update(rule.methods)
elif rule.websocket != websocket:
websocket_mismatch = True
else:
return rule, values
return None
try:
rv = _match(self._root, [domain, *path.split("/")], [])
except SlashRequired:
raise RequestPath(f"{path}/") from None
if self.merge_slashes and rv is None:
# Try to match again, but with slashes merged
path = re.sub("/{2,}?", "/", path)
try:
rv = _match(self._root, [domain, *path.split("/")], [])
except SlashRequired:
raise RequestPath(f"{path}/") from None
if rv is None:
raise NoMatch(have_match_for, websocket_mismatch)
else:
raise RequestPath(f"{path}")
elif rv is not None:
rule, values = rv
result = {}
for name, value in zip(rule._converters.keys(), values):
try:
value = rule._converters[name].to_python(value)
except ValidationError:
raise NoMatch(have_match_for, websocket_mismatch) from None
result[str(name)] = value
if rule.defaults:
result.update(rule.defaults)
if rule.alias and rule.map.redirect_defaults:
raise RequestAliasRedirect(result, rule.endpoint)
return rule, result
raise NoMatch(have_match_for, websocket_mismatch)