tessl/pypi-django-stubs
Comprehensive type stubs for Django framework enabling static type checking with mypy
—
Pending
urls.mddocs/
URL Routing
Django's URL routing system provides URL pattern matching, view resolution, reverse URL lookup, and URL configuration management for mapping URLs to view functions and classes.
Core Imports
# URL pattern functions
from django.urls import path, re_path, include
# URL utilities
from django.urls import reverse, reverse_lazy
# URL pattern classes
from django.urls.resolvers import URLPattern, URLResolver
# URL exceptions
from django.urls.exceptions import NoReverseMatch, Resolver404
# URL configuration
from django.conf.urls import handler404, handler500Capabilities
URL Pattern Definition
Functions for defining URL patterns with path and regex syntax.
def path(route: str, view, kwargs: dict = None, name: str = None) -> URLPattern:
"""
Define URL pattern with path syntax using angle brackets for parameters.
Args:
route (str): URL pattern with parameter syntax like 'articles/<int:year>/'
view: View function or class-based view
kwargs (dict, optional): Extra keyword arguments to pass to view
name (str, optional): Name for reverse URL lookup
Returns:
URLPattern: URL pattern object
"""
def re_path(route: str, view, kwargs: dict = None, name: str = None) -> URLPattern:
"""
Define URL pattern with regular expression syntax.
Args:
route (str): Regular expression pattern for URL matching
view: View function or class-based view
kwargs (dict, optional): Extra keyword arguments to pass to view
name (str, optional): Name for reverse URL lookup
Returns:
URLPattern: URL pattern object
"""
def include(arg, namespace: str = None) -> tuple:
"""
Include another URL configuration module or pattern list.
Args:
arg: Module path string, list of patterns, or (patterns, app_namespace) tuple
namespace (str, optional): Instance namespace for included URLs
Returns:
tuple: URL include configuration
"""URL Resolution and Reverse Lookup
Functions for resolving URLs to views and generating URLs from view names.
def reverse(viewname: str, urlconf: str = None, args: tuple = None, kwargs: dict = None, current_app: str = None) -> str:
"""
Reverse lookup URL from view name and parameters.
Args:
viewname (str): View name or dotted path to view
urlconf (str, optional): URL configuration module to use
args (tuple, optional): Positional arguments for URL parameters
kwargs (dict, optional): Keyword arguments for URL parameters
current_app (str, optional): Current application namespace
Returns:
str: Resolved URL path
"""
def reverse_lazy(viewname: str, urlconf: str = None, args: tuple = None, kwargs: dict = None, current_app: str = None):
"""
Lazy reverse lookup for use in settings and class definitions.
Returns a lazy object that resolves to URL when evaluated.
"""
def resolve(path: str, urlconf: str = None) -> ResolverMatch:
"""
Resolve URL path to view function and parameters.
Args:
path (str): URL path to resolve
urlconf (str, optional): URL configuration module to use
Returns:
ResolverMatch: Resolution result with view, args, kwargs, and names
"""URL Pattern Classes
Core classes representing URL patterns and resolution results.
class URLPattern:
"""Single URL pattern mapping route to view."""
def __init__(self, pattern, callback, default_args: dict = None, name: str = None): ...
def resolve(self, path: str) -> ResolverMatch: ...
def __repr__(self) -> str: ...
pattern: Any
callback: Any
default_args: dict
name: str
class URLResolver:
"""URL resolver for handling included URL configurations."""
def __init__(self, pattern, urlconf_name: str, default_kwargs: dict = None, app_name: str = None, namespace: str = None): ...
def resolve(self, path: str) -> ResolverMatch: ...
def reverse(self, lookup_view: str, *args, **kwargs) -> str: ...
def __repr__(self) -> str: ...
pattern: Any
urlconf_name: str
callback: Any
default_kwargs: dict
app_name: str
namespace: str
class ResolverMatch:
"""Result of URL resolution containing view and parameters."""
def __init__(self, func, args: tuple, kwargs: dict, url_name: str = None, app_names: list = None, namespaces: list = None, route: str = None): ...
func: Any # Resolved view function or class
args: tuple # Positional arguments from URL
kwargs: dict # Keyword arguments from URL
url_name: str # Name of matched URL pattern
view_name: str # Full dotted name of view
app_names: list # Application namespaces
namespaces: list # All namespaces
app_name: str # Current application namespace
namespace: str # Current namespace
route: str # Matched route patternURL Configuration Management
Functions for managing URL configuration and caching.
def get_resolver(urlconf: str = None):
"""
Get URL resolver for the given configuration.
Args:
urlconf (str, optional): URL configuration module path
Returns:
URLResolver: Main URL resolver instance
"""
def get_ns_resolver(ns_pattern: str, resolver, converters: dict):
"""Get namespace resolver for the given pattern."""
def get_callable(lookup_view):
"""
Convert string view name to callable view function.
Args:
lookup_view: String path or callable view
Returns:
callable: View function or class
"""
def get_mod_func(callback: str) -> tuple:
"""
Split callback string into module and function names.
Args:
callback (str): Dotted path to callback
Returns:
tuple: (module_name, function_name)
"""
def clear_url_caches() -> None:
"""Clear all URL resolver caches."""
def set_script_prefix(prefix: str) -> None:
"""Set script prefix for URL generation."""
def get_script_prefix() -> str:
"""Get current script prefix."""
def clear_script_prefix() -> None:
"""Clear script prefix."""
def set_urlconf(urlconf_name: str) -> None:
"""Set URL configuration for current thread."""
def get_urlconf(default: str = None) -> str:
"""Get URL configuration for current thread."""URL Validation and Utilities
Utility functions for URL validation and processing.
def is_valid_path(path: str, urlconf: str = None) -> bool:
"""
Check if URL path is valid (can be resolved).
Args:
path (str): URL path to validate
urlconf (str, optional): URL configuration to use
Returns:
bool: True if path can be resolved
"""
def translate_url(url: str, lang_code: str) -> str:
"""
Translate URL to given language code.
Args:
url (str): URL to translate
lang_code (str): Target language code
Returns:
str: Translated URL
"""URL Converters
Path converters for extracting typed parameters from URLs.
def register_converter(converter_class: type, type_name: str) -> None:
"""
Register custom URL parameter converter.
Args:
converter_class (type): Converter class with to_python and to_url methods
type_name (str): Name to use in URL patterns
"""
class IntConverter:
"""Converter for integer URL parameters."""
regex: str = '[0-9]+'
def to_python(self, value: str) -> int: ...
def to_url(self, value: int) -> str: ...
class StringConverter:
"""Converter for string URL parameters."""
regex: str = '[^/]+'
def to_python(self, value: str) -> str: ...
def to_url(self, value: str) -> str: ...
class UUIDConverter:
"""Converter for UUID URL parameters."""
regex: str = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
def to_python(self, value: str): ...
def to_url(self, value) -> str: ...
class SlugConverter:
"""Converter for slug URL parameters."""
regex: str = '[-a-zA-Z0-9_]+'
def to_python(self, value: str) -> str: ...
def to_url(self, value: str) -> str: ...
class PathConverter:
"""Converter for path URL parameters (including slashes)."""
regex: str = '.+'
def to_python(self, value: str) -> str: ...
def to_url(self, value: str) -> str: ...URL Exceptions
Exception classes for URL resolution and reverse lookup errors.
class Resolver404(Exception):
"""
Raised when URL resolution fails.
Indicates that no URL pattern matched the requested path.
"""
pass
class NoReverseMatch(Exception):
"""
Raised when reverse URL lookup fails.
Indicates that no URL pattern matches the given view name and parameters.
"""
passURL Pattern Matching
Internal classes for URL pattern compilation and matching.
class LocalePrefixPattern:
"""Pattern for matching locale prefixes in internationalized URLs."""
def __init__(self, prefix_default_language: bool = True): ...
def match(self, path: str) -> tuple: ...
def check(self) -> list: ...
def describe(self) -> str: ...
converters: dict
class RoutePattern:
"""Pattern for path-style URL routing with parameter extraction."""
def __init__(self, route: str, name: str = None, is_endpoint: bool = False): ...
def match(self, path: str) -> tuple: ...
def check(self) -> list: ...
def describe(self) -> str: ...
regex: Any
converters: dict
class RegexPattern:
"""Pattern for regex-style URL routing with group capture."""
def __init__(self, regex: str, name: str = None, is_endpoint: bool = False): ...
def match(self, path: str) -> tuple: ...
def check(self) -> list: ...
def describe(self) -> str: ...
regex: AnyInternationalization Support
URL internationalization utilities for multi-language sites.
def i18n_patterns(*urls, prefix_default_language: bool = True):
"""
Add language prefix to URL patterns for internationalization.
Args:
urls: URL patterns to internationalize
prefix_default_language (bool): Whether to prefix default language
Returns:
list: Internationalized URL patterns
"""
def is_language_prefix_patterns_used(urlconf: str = None) -> bool:
"""Check if language prefix patterns are used in URL configuration."""URL Types
Type aliases for URL pattern collections.
_AnyURL = URLPattern | URLResolver # Union type for URL patterns and resolversInstall with Tessl CLI
npx tessl i tessl/pypi-django-stubs