| 1 |
""" |
| 2 |
This module converts requested URLs to callback view functions. |
| 3 |
|
| 4 |
URLResolver is the main class here. Its resolve() method takes a URL (as |
| 5 |
a string) and returns a ResolverMatch object which provides access to all |
| 6 |
attributes of the resolved URL match. |
| 7 |
""" |
| 8 |
|
| 9 |
import functools |
| 10 |
import inspect |
| 11 |
import re |
| 12 |
import string |
| 13 |
from importlib import import_module |
| 14 |
from pickle import PicklingError |
| 15 |
from urllib.parse import quote |
| 16 |
|
| 17 |
from asgiref.local import Local |
| 18 |
|
| 19 |
from django.conf import settings |
| 20 |
from django.core.checks import Error, Warning |
| 21 |
from django.core.checks.urls import check_resolver |
| 22 |
from django.core.exceptions import ImproperlyConfigured |
| 23 |
from django.utils.datastructures import MultiValueDict |
| 24 |
from django.utils.functional import cached_property |
| 25 |
from django.utils.http import RFC3986_SUBDELIMS, escape_leading_slashes |
| 26 |
from django.utils.regex_helper import _lazy_re_compile, normalize |
| 27 |
from django.utils.translation import get_language |
| 28 |
|
| 29 |
from .converters import get_converters |
| 30 |
from .exceptions import NoReverseMatch, Resolver404 |
| 31 |
from .utils import get_callable |
| 32 |
|
| 33 |
|
| 34 |
class ResolverMatch: |
| 35 |
def __init__( |
| 36 |
self, |
| 37 |
func, |
| 38 |
args, |
| 39 |
kwargs, |
| 40 |
url_name=None, |
| 41 |
app_names=None, |
| 42 |
namespaces=None, |
| 43 |
route=None, |
| 44 |
tried=None, |
| 45 |
captured_kwargs=None, |
| 46 |
extra_kwargs=None, |
| 47 |
): |
| 48 |
self.func = func |
| 49 |
self.args = args |
| 50 |
self.kwargs = kwargs |
| 51 |
self.url_name = url_name |
| 52 |
self.route = route |
| 53 |
self.tried = tried |
| 54 |
self.captured_kwargs = captured_kwargs |
| 55 |
self.extra_kwargs = extra_kwargs |
| 56 |
|
| 57 |
# If a URLRegexResolver doesn't have a namespace or app_name, it passes |
| 58 |
# in an empty value. |
| 59 |
self.app_names = [x for x in app_names if x] if app_names else [] |
| 60 |
self.app_name = ":".join(self.app_names) |
| 61 |
self.namespaces = [x for x in namespaces if x] if namespaces else [] |
| 62 |
self.namespace = ":".join(self.namespaces) |
| 63 |
|
| 64 |
if hasattr(func, "view_class"): |
| 65 |
func = func.view_class |
| 66 |
if not hasattr(func, "__name__"): |
| 67 |
# A class-based view |
| 68 |
self._func_path = func.__class__.__module__ + "." + func.__class__.__name__ |
| 69 |
else: |
| 70 |
# A function-based view |
| 71 |
self._func_path = func.__module__ + "." + func.__name__ |
| 72 |
|
| 73 |
view_path = url_name or self._func_path |
| 74 |
self.view_name = ":".join(self.namespaces + [view_path]) |
| 75 |
|
| 76 |
def __getitem__(self, index): |
| 77 |
return (self.func, self.args, self.kwargs)[index] |
| 78 |
|
| 79 |
def __repr__(self): |
| 80 |
if isinstance(self.func, functools.partial): |
| 81 |
func = repr(self.func) |
| 82 |
else: |
| 83 |
func = self._func_path |
| 84 |
return ( |
| 85 |
"ResolverMatch(func=%s, args=%r, kwargs=%r, url_name=%r, " |
| 86 |
"app_names=%r, namespaces=%r, route=%r%s%s)" |
| 87 |
% ( |
| 88 |
func, |
| 89 |
self.args, |
| 90 |
self.kwargs, |
| 91 |
self.url_name, |
| 92 |
self.app_names, |
| 93 |
self.namespaces, |
| 94 |
self.route, |
| 95 |
( |
| 96 |
f", captured_kwargs={self.captured_kwargs!r}" |
| 97 |
if self.captured_kwargs |
| 98 |
else "" |
| 99 |
), |
| 100 |
f", extra_kwargs={self.extra_kwargs!r}" if self.extra_kwargs else "", |
| 101 |
) |
| 102 |
) |
| 103 |
|
| 104 |
def __reduce_ex__(self, protocol): |
| 105 |
raise PicklingError(f"Cannot pickle {self.__class__.__qualname__}.") |
| 106 |
|
| 107 |
|
| 108 |
def get_resolver(urlconf=None): |
| 109 |
if urlconf is None: |
| 110 |
urlconf = settings.ROOT_URLCONF |
| 111 |
return _get_cached_resolver(urlconf) |
| 112 |
|
| 113 |
|
| 114 |
@functools.cache |
| 115 |
def _get_cached_resolver(urlconf=None): |
| 116 |
return URLResolver(RegexPattern(r"^/"), urlconf) |
| 117 |
|
| 118 |
|
| 119 |
@functools.cache |
| 120 |
def get_ns_resolver(ns_pattern, resolver, converters): |
| 121 |
# Build a namespaced resolver for the given parent URLconf pattern. |
| 122 |
# This makes it possible to have captured parameters in the parent |
| 123 |
# URLconf pattern. |
| 124 |
pattern = RegexPattern(ns_pattern) |
| 125 |
pattern.converters = dict(converters) |
| 126 |
ns_resolver = URLResolver(pattern, resolver.url_patterns) |
| 127 |
return URLResolver(RegexPattern(r"^/"), [ns_resolver]) |
| 128 |
|
| 129 |
|
| 130 |
class LocaleRegexDescriptor: |
| 131 |
def __get__(self, instance, cls=None): |
| 132 |
""" |
| 133 |
Return a compiled regular expression based on the active language. |
| 134 |
""" |
| 135 |
if instance is None: |
| 136 |
return self |
| 137 |
# As a performance optimization, if the given regex string is a regular |
| 138 |
# string (not a lazily-translated string proxy), compile it once and |
| 139 |
# avoid per-language compilation. |
| 140 |
pattern = instance._regex |
| 141 |
if isinstance(pattern, str): |
| 142 |
instance.__dict__["regex"] = self._compile(pattern) |
| 143 |
return instance.__dict__["regex"] |
| 144 |
language_code = get_language() |
| 145 |
if language_code not in instance._regex_dict: |
| 146 |
instance._regex_dict[language_code] = self._compile(str(pattern)) |
| 147 |
return instance._regex_dict[language_code] |
| 148 |
|
| 149 |
def _compile(self, regex): |
| 150 |
try: |
| 151 |
return re.compile(regex) |
| 152 |
except re.error as e: |
| 153 |
raise ImproperlyConfigured( |
| 154 |
f'"{regex}" is not a valid regular expression: {e}' |
| 155 |
) from e |
| 156 |
|
| 157 |
|
| 158 |
class CheckURLMixin: |
| 159 |
def describe(self): |
| 160 |
""" |
| 161 |
Format the URL pattern for display in warning messages. |
| 162 |
""" |
| 163 |
description = "'{}'".format(self) |
| 164 |
if self.name: |
| 165 |
description += " [name='{}']".format(self.name) |
| 166 |
return description |
| 167 |
|
| 168 |
def _check_pattern_startswith_slash(self): |
| 169 |
""" |
| 170 |
Check that the pattern does not begin with a forward slash. |
| 171 |
""" |
| 172 |
if not settings.APPEND_SLASH: |
| 173 |
# Skip check as it can be useful to start a URL pattern with a slash |
| 174 |
# when APPEND_SLASH=False. |
| 175 |
return [] |
| 176 |
if self._regex.startswith(("/", "^/", "^\\/")) and not self._regex.endswith( |
| 177 |
"/" |
| 178 |
): |
| 179 |
warning = Warning( |
| 180 |
"Your URL pattern {} has a route beginning with a '/'. Remove this " |
| 181 |
"slash as it is unnecessary. If this pattern is targeted in an " |
| 182 |
"include(), ensure the include() pattern has a trailing '/'.".format( |
| 183 |
self.describe() |
| 184 |
), |
| 185 |
id="urls.W002", |
| 186 |
) |
| 187 |
return [warning] |
| 188 |
else: |
| 189 |
return [] |
| 190 |
|
| 191 |
|
| 192 |
class RegexPattern(CheckURLMixin): |
| 193 |
regex = LocaleRegexDescriptor() |
| 194 |
|
| 195 |
def __init__(self, regex, name=None, is_endpoint=False): |
| 196 |
self._regex = regex |
| 197 |
self._regex_dict = {} |
| 198 |
self._is_endpoint = is_endpoint |
| 199 |
self.name = name |
| 200 |
self.converters = {} |
| 201 |
|
| 202 |
def match(self, path): |
| 203 |
match = ( |
| 204 |
self.regex.fullmatch(path) |
| 205 |
if self._is_endpoint and self.regex.pattern.endswith("$") |
| 206 |
else self.regex.search(path) |
| 207 |
) |
| 208 |
if match: |
| 209 |
# If there are any named groups, use those as kwargs, ignoring |
| 210 |
# non-named groups. Otherwise, pass all non-named arguments as |
| 211 |
# positional arguments. |
| 212 |
kwargs = match.groupdict() |
| 213 |
args = () if kwargs else match.groups() |
| 214 |
kwargs = {k: v for k, v in kwargs.items() if v is not None} |
| 215 |
return path[match.end() :], args, kwargs |
| 216 |
return None |
| 217 |
|
| 218 |
def check(self): |
| 219 |
warnings = [] |
| 220 |
warnings.extend(self._check_pattern_startswith_slash()) |
| 221 |
if not self._is_endpoint: |
| 222 |
warnings.extend(self._check_include_trailing_dollar()) |
| 223 |
return warnings |
| 224 |
|
| 225 |
def _check_include_trailing_dollar(self): |
| 226 |
if self._regex.endswith("$") and not self._regex.endswith(r"\$"): |
| 227 |
return [ |
| 228 |
Warning( |
| 229 |
"Your URL pattern {} uses include with a route ending with a '$'. " |
| 230 |
"Remove the dollar from the route to avoid problems including " |
| 231 |
"URLs.".format(self.describe()), |
| 232 |
id="urls.W001", |
| 233 |
) |
| 234 |
] |
| 235 |
else: |
| 236 |
return [] |
| 237 |
|
| 238 |
def __str__(self): |
| 239 |
return str(self._regex) |
| 240 |
|
| 241 |
|
| 242 |
_PATH_PARAMETER_COMPONENT_RE = _lazy_re_compile( |
| 243 |
r"<(?:(?P<converter>[^>:]+):)?(?P<parameter>[^>]+)>" |
| 244 |
) |
| 245 |
|
| 246 |
whitespace_set = frozenset(string.whitespace) |
| 247 |
|
| 248 |
|
| 249 |
@functools.lru_cache |
| 250 |
def _route_to_regex(route, is_endpoint): |
| 251 |
""" |
| 252 |
Convert a path pattern into a regular expression. Return the regular |
| 253 |
expression and a dictionary mapping the capture names to the converters. |
| 254 |
For example, 'foo/<int:pk>' returns '^foo\\/(?P<pk>[0-9]+)' |
| 255 |
and {'pk': <django.urls.converters.IntConverter>}. |
| 256 |
""" |
| 257 |
parts = ["^"] |
| 258 |
all_converters = get_converters() |
| 259 |
converters = {} |
| 260 |
previous_end = 0 |
| 261 |
for match_ in _PATH_PARAMETER_COMPONENT_RE.finditer(route): |
| 262 |
if not whitespace_set.isdisjoint(match_[0]): |
| 263 |
raise ImproperlyConfigured( |
| 264 |
f"URL route {route!r} cannot contain whitespace in angle brackets <…>." |
| 265 |
) |
| 266 |
# Default to make converter "str" if unspecified (parameter always |
| 267 |
# matches something). |
| 268 |
raw_converter, parameter = match_.groups(default="str") |
| 269 |
if not parameter.isidentifier(): |
| 270 |
raise ImproperlyConfigured( |
| 271 |
f"URL route {route!r} uses parameter name {parameter!r} which " |
| 272 |
"isn't a valid Python identifier." |
| 273 |
) |
| 274 |
try: |
| 275 |
converter = all_converters[raw_converter] |
| 276 |
except KeyError as e: |
| 277 |
raise ImproperlyConfigured( |
| 278 |
f"URL route {route!r} uses invalid converter {raw_converter!r}." |
| 279 |
) from e |
| 280 |
converters[parameter] = converter |
| 281 |
|
| 282 |
start, end = match_.span() |
| 283 |
parts.append(re.escape(route[previous_end:start])) |
| 284 |
previous_end = end |
| 285 |
parts.append(f"(?P<{parameter}>{converter.regex})") |
| 286 |
|
| 287 |
parts.append(re.escape(route[previous_end:])) |
| 288 |
if is_endpoint: |
| 289 |
parts.append(r"\Z") |
| 290 |
return "".join(parts), converters |
| 291 |
|
| 292 |
|
| 293 |
class LocaleRegexRouteDescriptor: |
| 294 |
def __get__(self, instance, cls=None): |
| 295 |
""" |
| 296 |
Return a compiled regular expression based on the active language. |
| 297 |
""" |
| 298 |
if instance is None: |
| 299 |
return self |
| 300 |
# As a performance optimization, if the given route is a regular string |
| 301 |
# (not a lazily-translated string proxy), compile it once and avoid |
| 302 |
# per-language compilation. |
| 303 |
if isinstance(instance._route, str): |
| 304 |
instance.__dict__["regex"] = re.compile(instance._regex) |
| 305 |
return instance.__dict__["regex"] |
| 306 |
language_code = get_language() |
| 307 |
if language_code not in instance._regex_dict: |
| 308 |
instance._regex_dict[language_code] = re.compile( |
| 309 |
_route_to_regex(str(instance._route), instance._is_endpoint)[0] |
| 310 |
) |
| 311 |
return instance._regex_dict[language_code] |
| 312 |
|
| 313 |
|
| 314 |
class RoutePattern(CheckURLMixin): |
| 315 |
regex = LocaleRegexRouteDescriptor() |
| 316 |
|
| 317 |
def __init__(self, route, name=None, is_endpoint=False): |
| 318 |
self._route = route |
| 319 |
self._regex, self.converters = _route_to_regex(str(route), is_endpoint) |
| 320 |
self._regex_dict = {} |
| 321 |
self._is_endpoint = is_endpoint |
| 322 |
self.name = name |
| 323 |
|
| 324 |
def match(self, path): |
| 325 |
match = self.regex.search(path) |
| 326 |
if match: |
| 327 |
# RoutePattern doesn't allow non-named groups so args are ignored. |
| 328 |
kwargs = match.groupdict() |
| 329 |
for key, value in kwargs.items(): |
| 330 |
converter = self.converters[key] |
| 331 |
try: |
| 332 |
kwargs[key] = converter.to_python(value) |
| 333 |
except ValueError: |
| 334 |
return None |
| 335 |
return path[match.end() :], (), kwargs |
| 336 |
return None |
| 337 |
|
| 338 |
def check(self): |
| 339 |
warnings = [ |
| 340 |
*self._check_pattern_startswith_slash(), |
| 341 |
*self._check_pattern_unmatched_angle_brackets(), |
| 342 |
] |
| 343 |
route = self._route |
| 344 |
if "(?P<" in route or route.startswith("^") or route.endswith("$"): |
| 345 |
warnings.append( |
| 346 |
Warning( |
| 347 |
"Your URL pattern {} has a route that contains '(?P<', begins " |
| 348 |
"with a '^', or ends with a '$'. This was likely an oversight " |
| 349 |
"when migrating to django.urls.path().".format(self.describe()), |
| 350 |
id="2_0.W001", |
| 351 |
) |
| 352 |
) |
| 353 |
return warnings |
| 354 |
|
| 355 |
def _check_pattern_unmatched_angle_brackets(self): |
| 356 |
warnings = [] |
| 357 |
msg = "Your URL pattern %s has an unmatched '%s' bracket." |
| 358 |
brackets = re.findall(r"[<>]", str(self._route)) |
| 359 |
open_bracket_counter = 0 |
| 360 |
for bracket in brackets: |
| 361 |
if bracket == "<": |
| 362 |
open_bracket_counter += 1 |
| 363 |
elif bracket == ">": |
| 364 |
open_bracket_counter -= 1 |
| 365 |
if open_bracket_counter < 0: |
| 366 |
warnings.append( |
| 367 |
Warning(msg % (self.describe(), ">"), id="urls.W010") |
| 368 |
) |
| 369 |
open_bracket_counter = 0 |
| 370 |
if open_bracket_counter > 0: |
| 371 |
warnings.append(Warning(msg % (self.describe(), "<"), id="urls.W010")) |
| 372 |
return warnings |
| 373 |
|
| 374 |
def __str__(self): |
| 375 |
return str(self._route) |
| 376 |
|
| 377 |
|
| 378 |
class LocalePrefixPattern: |
| 379 |
def __init__(self, prefix_default_language=True): |
| 380 |
self.prefix_default_language = prefix_default_language |
| 381 |
self.converters = {} |
| 382 |
|
| 383 |
@property |
| 384 |
def regex(self): |
| 385 |
# This is only used by reverse() and cached in _reverse_dict. |
| 386 |
return re.compile(re.escape(self.language_prefix)) |
| 387 |
|
| 388 |
@property |
| 389 |
def language_prefix(self): |
| 390 |
language_code = get_language() or settings.LANGUAGE_CODE |
| 391 |
if language_code == settings.LANGUAGE_CODE and not self.prefix_default_language: |
| 392 |
return "" |
| 393 |
else: |
| 394 |
return "%s/" % language_code |
| 395 |
|
| 396 |
def match(self, path): |
| 397 |
language_prefix = self.language_prefix |
| 398 |
if path.startswith(language_prefix): |
| 399 |
return path.removeprefix(language_prefix), (), {} |
| 400 |
return None |
| 401 |
|
| 402 |
def check(self): |
| 403 |
return [] |
| 404 |
|
| 405 |
def describe(self): |
| 406 |
return "'{}'".format(self) |
| 407 |
|
| 408 |
def __str__(self): |
| 409 |
return self.language_prefix |
| 410 |
|
| 411 |
|
| 412 |
class URLPattern: |
| 413 |
def __init__(self, pattern, callback, default_args=None, name=None): |
| 414 |
self.pattern = pattern |
| 415 |
self.callback = callback # the view |
| 416 |
self.default_args = default_args or {} |
| 417 |
self.name = name |
| 418 |
|
| 419 |
def __repr__(self): |
| 420 |
return "<%s %s>" % (self.__class__.__name__, self.pattern.describe()) |
| 421 |
|
| 422 |
def check(self): |
| 423 |
warnings = self._check_pattern_name() |
| 424 |
warnings.extend(self.pattern.check()) |
| 425 |
warnings.extend(self._check_callback()) |
| 426 |
return warnings |
| 427 |
|
| 428 |
def _check_pattern_name(self): |
| 429 |
""" |
| 430 |
Check that the pattern name does not contain a colon. |
| 431 |
""" |
| 432 |
if self.pattern.name is not None and ":" in self.pattern.name: |
| 433 |
warning = Warning( |
| 434 |
"Your URL pattern {} has a name including a ':'. Remove the colon, to " |
| 435 |
"avoid ambiguous namespace references.".format(self.pattern.describe()), |
| 436 |
id="urls.W003", |
| 437 |
) |
| 438 |
return [warning] |
| 439 |
else: |
| 440 |
return [] |
| 441 |
|
| 442 |
def _check_callback(self): |
| 443 |
from django.views import View |
| 444 |
|
| 445 |
view = self.callback |
| 446 |
if inspect.isclass(view) and issubclass(view, View): |
| 447 |
return [ |
| 448 |
Error( |
| 449 |
"Your URL pattern %s has an invalid view, pass %s.as_view() " |
| 450 |
"instead of %s." |
| 451 |
% ( |
| 452 |
self.pattern.describe(), |
| 453 |
view.__name__, |
| 454 |
view.__name__, |
| 455 |
), |
| 456 |
id="urls.E009", |
| 457 |
) |
| 458 |
] |
| 459 |
return [] |
| 460 |
|
| 461 |
def resolve(self, path): |
| 462 |
match = self.pattern.match(path) |
| 463 |
if match: |
| 464 |
new_path, args, captured_kwargs = match |
| 465 |
# Pass any default args as **kwargs. |
| 466 |
kwargs = {**captured_kwargs, **self.default_args} |
| 467 |
return ResolverMatch( |
| 468 |
self.callback, |
| 469 |
args, |
| 470 |
kwargs, |
| 471 |
self.pattern.name, |
| 472 |
route=str(self.pattern), |
| 473 |
captured_kwargs=captured_kwargs, |
| 474 |
extra_kwargs=self.default_args, |
| 475 |
) |
| 476 |
|
| 477 |
@cached_property |
| 478 |
def lookup_str(self): |
| 479 |
""" |
| 480 |
A string that identifies the view (e.g. 'path.to.view_function' or |
| 481 |
'path.to.ClassBasedView'). |
| 482 |
""" |
| 483 |
callback = self.callback |
| 484 |
if isinstance(callback, functools.partial): |
| 485 |
callback = callback.func |
| 486 |
if hasattr(callback, "view_class"): |
| 487 |
callback = callback.view_class |
| 488 |
elif not hasattr(callback, "__name__"): |
| 489 |
return callback.__module__ + "." + callback.__class__.__name__ |
| 490 |
return callback.__module__ + "." + callback.__qualname__ |
| 491 |
|
| 492 |
|
| 493 |
class URLResolver: |
| 494 |
def __init__( |
| 495 |
self, pattern, urlconf_name, default_kwargs=None, app_name=None, namespace=None |
| 496 |
): |
| 497 |
self.pattern = pattern |
| 498 |
# urlconf_name is the dotted Python path to the module defining |
| 499 |
# urlpatterns. It may also be an object with an urlpatterns attribute |
| 500 |
# or urlpatterns itself. |
| 501 |
self.urlconf_name = urlconf_name |
| 502 |
self.callback = None |
| 503 |
self.default_kwargs = default_kwargs or {} |
| 504 |
self.namespace = namespace |
| 505 |
self.app_name = app_name |
| 506 |
self._reverse_dict = {} |
| 507 |
self._namespace_dict = {} |
| 508 |
self._app_dict = {} |
| 509 |
# set of dotted paths to all functions and classes that are used in |
| 510 |
# urlpatterns |
| 511 |
self._callback_strs = set() |
| 512 |
self._populated = False |
| 513 |
self._local = Local() |
| 514 |
|
| 515 |
def __repr__(self): |
| 516 |
if isinstance(self.urlconf_name, list) and self.urlconf_name: |
| 517 |
# Don't bother to output the whole list, it can be huge |
| 518 |
urlconf_repr = "<%s list>" % self.urlconf_name[0].__class__.__name__ |
| 519 |
else: |
| 520 |
urlconf_repr = repr(self.urlconf_name) |
| 521 |
return "<%s %s (%s:%s) %s>" % ( |
| 522 |
self.__class__.__name__, |
| 523 |
urlconf_repr, |
| 524 |
self.app_name, |
| 525 |
self.namespace, |
| 526 |
self.pattern.describe(), |
| 527 |
) |
| 528 |
|
| 529 |
def check(self): |
| 530 |
messages = [] |
| 531 |
for pattern in self.url_patterns: |
| 532 |
messages.extend(check_resolver(pattern)) |
| 533 |
return messages or self.pattern.check() |
| 534 |
|
| 535 |
def _populate(self): |
| 536 |
# Short-circuit if called recursively in this thread to prevent |
| 537 |
# infinite recursion. Concurrent threads may call this at the same |
| 538 |
# time and will need to continue, so set 'populating' on a |
| 539 |
# thread-local variable. |
| 540 |
if getattr(self._local, "populating", False): |
| 541 |
return |
| 542 |
try: |
| 543 |
self._local.populating = True |
| 544 |
lookups = MultiValueDict() |
| 545 |
namespaces = {} |
| 546 |
apps = {} |
| 547 |
language_code = get_language() |
| 548 |
for url_pattern in reversed(self.url_patterns): |
| 549 |
p_pattern = url_pattern.pattern.regex.pattern |
| 550 |
p_pattern = p_pattern.removeprefix("^") |
| 551 |
if isinstance(url_pattern, URLPattern): |
| 552 |
self._callback_strs.add(url_pattern.lookup_str) |
| 553 |
bits = normalize(url_pattern.pattern.regex.pattern) |
| 554 |
lookups.appendlist( |
| 555 |
url_pattern.callback, |
| 556 |
( |
| 557 |
bits, |
| 558 |
p_pattern, |
| 559 |
url_pattern.default_args, |
| 560 |
url_pattern.pattern.converters, |
| 561 |
), |
| 562 |
) |
| 563 |
if url_pattern.name is not None: |
| 564 |
lookups.appendlist( |
| 565 |
url_pattern.name, |
| 566 |
( |
| 567 |
bits, |
| 568 |
p_pattern, |
| 569 |
url_pattern.default_args, |
| 570 |
url_pattern.pattern.converters, |
| 571 |
), |
| 572 |
) |
| 573 |
else: # url_pattern is a URLResolver. |
| 574 |
url_pattern._populate() |
| 575 |
if url_pattern.app_name: |
| 576 |
apps.setdefault(url_pattern.app_name, []).append( |
| 577 |
url_pattern.namespace |
| 578 |
) |
| 579 |
namespaces[url_pattern.namespace] = (p_pattern, url_pattern) |
| 580 |
else: |
| 581 |
for name in url_pattern.reverse_dict: |
| 582 |
for ( |
| 583 |
matches, |
| 584 |
pat, |
| 585 |
defaults, |
| 586 |
converters, |
| 587 |
) in url_pattern.reverse_dict.getlist(name): |
| 588 |
new_matches = normalize(p_pattern + pat) |
| 589 |
lookups.appendlist( |
| 590 |
name, |
| 591 |
( |
| 592 |
new_matches, |
| 593 |
p_pattern + pat, |
| 594 |
{**defaults, **url_pattern.default_kwargs}, |
| 595 |
{ |
| 596 |
**self.pattern.converters, |
| 597 |
**url_pattern.pattern.converters, |
| 598 |
**converters, |
| 599 |
}, |
| 600 |
), |
| 601 |
) |
| 602 |
for namespace, ( |
| 603 |
prefix, |
| 604 |
sub_pattern, |
| 605 |
) in url_pattern.namespace_dict.items(): |
| 606 |
current_converters = url_pattern.pattern.converters |
| 607 |
sub_pattern.pattern.converters.update(current_converters) |
| 608 |
namespaces[namespace] = (p_pattern + prefix, sub_pattern) |
| 609 |
for app_name, namespace_list in url_pattern.app_dict.items(): |
| 610 |
apps.setdefault(app_name, []).extend(namespace_list) |
| 611 |
self._callback_strs.update(url_pattern._callback_strs) |
| 612 |
self._namespace_dict[language_code] = namespaces |
| 613 |
self._app_dict[language_code] = apps |
| 614 |
self._reverse_dict[language_code] = lookups |
| 615 |
self._populated = True |
| 616 |
finally: |
| 617 |
self._local.populating = False |
| 618 |
|
| 619 |
@property |
| 620 |
def reverse_dict(self): |
| 621 |
language_code = get_language() |
| 622 |
if language_code not in self._reverse_dict: |
| 623 |
self._populate() |
| 624 |
return self._reverse_dict[language_code] |
| 625 |
|
| 626 |
@property |
| 627 |
def namespace_dict(self): |
| 628 |
language_code = get_language() |
| 629 |
if language_code not in self._namespace_dict: |
| 630 |
self._populate() |
| 631 |
return self._namespace_dict[language_code] |
| 632 |
|
| 633 |
@property |
| 634 |
def app_dict(self): |
| 635 |
language_code = get_language() |
| 636 |
if language_code not in self._app_dict: |
| 637 |
self._populate() |
| 638 |
return self._app_dict[language_code] |
| 639 |
|
| 640 |
@staticmethod |
| 641 |
def _extend_tried(tried, pattern, sub_tried=None): |
| 642 |
if sub_tried is None: |
| 643 |
tried.append([pattern]) |
| 644 |
else: |
| 645 |
tried.extend([pattern, *t] for t in sub_tried) |
| 646 |
|
| 647 |
@staticmethod |
| 648 |
def _join_route(route1, route2): |
| 649 |
"""Join two routes, without the starting ^ in the second route.""" |
| 650 |
if not route1: |
| 651 |
return route2 |
| 652 |
route2 = route2.removeprefix("^") |
| 653 |
return route1 + route2 |
| 654 |
|
| 655 |
def _is_callback(self, name): |
| 656 |
if not self._populated: |
| 657 |
self._populate() |
| 658 |
return name in self._callback_strs |
| 659 |
|
| 660 |
def resolve(self, path): |
| 661 |
path = str(path) # path may be a reverse_lazy object |
| 662 |
tried = [] |
| 663 |
match = self.pattern.match(path) |
| 664 |
if match: |
| 665 |
new_path, args, kwargs = match |
| 666 |
for pattern in self.url_patterns: |
| 667 |
try: |
| 668 |
sub_match = pattern.resolve(new_path) |
| 669 |
except Resolver404 as e: |
| 670 |
self._extend_tried(tried, pattern, e.args[0].get("tried")) |
| 671 |
else: |
| 672 |
if sub_match: |
| 673 |
# Merge captured arguments in match with submatch |
| 674 |
sub_match_dict = {**kwargs, **self.default_kwargs} |
| 675 |
# Update the sub_match_dict with the kwargs from the sub_match. |
| 676 |
sub_match_dict.update(sub_match.kwargs) |
| 677 |
# If there are *any* named groups, ignore all non-named groups. |
| 678 |
# Otherwise, pass all non-named arguments as positional |
| 679 |
# arguments. |
| 680 |
sub_match_args = sub_match.args |
| 681 |
if not sub_match_dict: |
| 682 |
sub_match_args = args + sub_match.args |
| 683 |
current_route = ( |
| 684 |
"" |
| 685 |
if isinstance(pattern, URLPattern) |
| 686 |
else str(pattern.pattern) |
| 687 |
) |
| 688 |
self._extend_tried(tried, pattern, sub_match.tried) |
| 689 |
return ResolverMatch( |
| 690 |
sub_match.func, |
| 691 |
sub_match_args, |
| 692 |
sub_match_dict, |
| 693 |
sub_match.url_name, |
| 694 |
[self.app_name] + sub_match.app_names, |
| 695 |
[self.namespace] + sub_match.namespaces, |
| 696 |
self._join_route(current_route, sub_match.route), |
| 697 |
tried, |
| 698 |
captured_kwargs=sub_match.captured_kwargs, |
| 699 |
extra_kwargs={ |
| 700 |
**self.default_kwargs, |
| 701 |
**sub_match.extra_kwargs, |
| 702 |
}, |
| 703 |
) |
| 704 |
tried.append([pattern]) |
| 705 |
raise Resolver404({"tried": tried, "path": new_path}) |
| 706 |
raise Resolver404({"path": path}) |
| 707 |
|
| 708 |
@cached_property |
| 709 |
def urlconf_module(self): |
| 710 |
if isinstance(self.urlconf_name, str): |
| 711 |
return import_module(self.urlconf_name) |
| 712 |
else: |
| 713 |
return self.urlconf_name |
| 714 |
|
| 715 |
@cached_property |
| 716 |
def url_patterns(self): |
| 717 |
# urlconf_module might be a valid set of patterns, so we default to it |
| 718 |
patterns = getattr(self.urlconf_module, "urlpatterns", self.urlconf_module) |
| 719 |
try: |
| 720 |
iter(patterns) |
| 721 |
except TypeError as e: |
| 722 |
msg = ( |
| 723 |
"The included URLconf '{name}' does not appear to have " |
| 724 |
"any patterns in it. If you see the 'urlpatterns' variable " |
| 725 |
"with valid patterns in the file then the issue is probably " |
| 726 |
"caused by a circular import." |
| 727 |
) |
| 728 |
raise ImproperlyConfigured(msg.format(name=self.urlconf_name)) from e |
| 729 |
return patterns |
| 730 |
|
| 731 |
def resolve_error_handler(self, view_type): |
| 732 |
callback = getattr(self.urlconf_module, "handler%s" % view_type, None) |
| 733 |
if not callback: |
| 734 |
# No handler specified in file; use lazy import, since |
| 735 |
# django.conf.urls imports this file. |
| 736 |
from django.conf import urls |
| 737 |
|
| 738 |
callback = getattr(urls, "handler%s" % view_type) |
| 739 |
return get_callable(callback) |
| 740 |
|
| 741 |
def reverse(self, lookup_view, *args, **kwargs): |
| 742 |
return self._reverse_with_prefix(lookup_view, "", *args, **kwargs) |
| 743 |
|
| 744 |
def _reverse_with_prefix(self, lookup_view, _prefix, *args, **kwargs): |
| 745 |
if args and kwargs: |
| 746 |
raise ValueError("Don't mix *args and **kwargs in call to reverse()!") |
| 747 |
|
| 748 |
if not self._populated: |
| 749 |
self._populate() |
| 750 |
|
| 751 |
possibilities = self.reverse_dict.getlist(lookup_view) |
| 752 |
|
| 753 |
for possibility, pattern, defaults, converters in possibilities: |
| 754 |
for result, params in possibility: |
| 755 |
if args: |
| 756 |
if len(args) != len(params): |
| 757 |
continue |
| 758 |
candidate_subs = dict(zip(params, args)) |
| 759 |
else: |
| 760 |
if set(kwargs).symmetric_difference(params).difference(defaults): |
| 761 |
continue |
| 762 |
matches = True |
| 763 |
for k, v in defaults.items(): |
| 764 |
if k in params: |
| 765 |
continue |
| 766 |
if kwargs.get(k, v) != v: |
| 767 |
matches = False |
| 768 |
break |
| 769 |
if not matches: |
| 770 |
continue |
| 771 |
candidate_subs = kwargs |
| 772 |
# Convert the candidate subs to text using Converter.to_url(). |
| 773 |
text_candidate_subs = {} |
| 774 |
match = True |
| 775 |
for k, v in candidate_subs.items(): |
| 776 |
if k in converters: |
| 777 |
try: |
| 778 |
text_candidate_subs[k] = converters[k].to_url(v) |
| 779 |
except ValueError: |
| 780 |
match = False |
| 781 |
break |
| 782 |
else: |
| 783 |
text_candidate_subs[k] = str(v) |
| 784 |
if not match: |
| 785 |
continue |
| 786 |
# WSGI provides decoded URLs, without %xx escapes, and the URL |
| 787 |
# resolver operates on such URLs. First substitute arguments |
| 788 |
# without quoting to build a decoded URL and look for a match. |
| 789 |
# Then, if we have a match, redo the substitution with quoted |
| 790 |
# arguments in order to return a properly encoded URL. |
| 791 |
candidate_pat = _prefix.replace("%", "%%") + result |
| 792 |
if re.search( |
| 793 |
"^%s%s" % (re.escape(_prefix), pattern), |
| 794 |
candidate_pat % text_candidate_subs, |
| 795 |
): |
| 796 |
# safe characters from `pchar` definition of RFC 3986 |
| 797 |
url = quote( |
| 798 |
candidate_pat % text_candidate_subs, |
| 799 |
safe=RFC3986_SUBDELIMS + "/~:@", |
| 800 |
) |
| 801 |
# Don't allow construction of scheme relative urls. |
| 802 |
return escape_leading_slashes(url) |
| 803 |
# lookup_view can be URL name or callable, but callables are not |
| 804 |
# friendly in error messages. |
| 805 |
m = getattr(lookup_view, "__module__", None) |
| 806 |
n = getattr(lookup_view, "__name__", None) |
| 807 |
if m is not None and n is not None: |
| 808 |
lookup_view_s = "%s.%s" % (m, n) |
| 809 |
else: |
| 810 |
lookup_view_s = lookup_view |
| 811 |
|
| 812 |
patterns = [pattern for (_, pattern, _, _) in possibilities] |
| 813 |
if patterns: |
| 814 |
if args: |
| 815 |
arg_msg = "arguments '%s'" % (args,) |
| 816 |
elif kwargs: |
| 817 |
arg_msg = "keyword arguments '%s'" % kwargs |
| 818 |
else: |
| 819 |
arg_msg = "no arguments" |
| 820 |
msg = "Reverse for '%s' with %s not found. %d pattern(s) tried: %s" % ( |
| 821 |
lookup_view_s, |
| 822 |
arg_msg, |
| 823 |
len(patterns), |
| 824 |
patterns, |
| 825 |
) |
| 826 |
else: |
| 827 |
msg = ( |
| 828 |
"Reverse for '%(view)s' not found. '%(view)s' is not " |
| 829 |
"a valid view function or pattern name." % {"view": lookup_view_s} |
| 830 |
) |
| 831 |
raise NoReverseMatch(msg) |