django-fastresolve 0.1.0__tar.gz

django_fastresolve-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+*.py[cod]
+__pycache__
+venv
+.venv
+.DS_Store
+.pytest_cache
+*.egg-info
+dist
+build
+.coverage
+htmlcov
+testreport.xml
+mutants

django_fastresolve-0.1.0/HISTORY.rst

@@ -0,0 +1,7 @@
+Changelog
+---------
+
+0.1.0
+~~~~~
+
+* Initial release

django_fastresolve-0.1.0/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2026, Anders Hovmöller
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of django-fastdev nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

django_fastresolve-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.5
+Name: django-fastresolve
+Version: 0.1.0
+Summary: Faster URL resolving for Django, by indexing url patterns on their literal prefixes
+Project-URL: Homepage, https://github.com/boxed/django-fastresolve
+Author-email: Anders Hovmöller <boxed@killingar.net>
+License: BSD
+License-File: LICENSE
+Keywords: django,performance,urls
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Framework :: Django :: 5.2
+Classifier: Framework :: Django :: 6.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Description-Content-Type: text/x-rst
+
+django-fastresolve
+==================
+
+Faster URL resolving for Django, as a drop-in. No changes to your urlconfs.
+
+Django resolves a path by trying every pattern of a urlconf in order, recursing
+into includes. With a few hundred patterns at one level, every request pays for
+a few hundred regex searches or string compares, and a 404 pays for all of them.
+
+django-fastresolve indexes the patterns of each resolver on their *literal
+prefix*: the text a path must start with for the pattern to have any chance of
+matching (``'projects/'`` for ``path('projects/<int:pk>/', ...)``, ``'blog/'``
+for ``re_path(r'^blog/(?P<slug>\w+)/$', ...)``). A path then only tries the
+patterns whose prefix it starts with, still in their original order. All the
+matching itself is still Django's own code: converters, a ``to_python`` raising
+``ValueError`` falling through to later patterns, namespaces, default kwargs.
+
+
+Installation
+------------
+
+.. code-block::
+
+    pip install django-fastresolve
+
+and add ``'django_fastresolve'`` to ``INSTALLED_APPS``. That's it.
+
+You can also call ``django_fastresolve.install()`` and
+``django_fastresolve.uninstall()`` yourself.
+
+
+How much faster?
+----------------
+
+On a real project with three urlconfs, timing ``resolve()`` on every route,
+with ``DEBUG = False``:
+
+=====================  ======  ============  ==============  ==========  ==========
+urlconf                routes  stock median  fast median     stock 404   fast 404
+=====================  ======  ============  ==============  ==========  ==========
+internal app           785     25 µs         6 µs            27 µs       2 µs
+public site            894     64 µs         4.6 µs          125 µs      4.8 µs
+small                  83      8 µs          7 µs            6 µs        3 µs
+=====================  ======  ============  ==============  ==========  ==========
+
+The more patterns share a level, the bigger the win. Patterns that stock Django
+already finds in the first couple of tries get about 1 µs slower, from the
+index lookup.
+
+
+When does it fall back?
+-----------------------
+
+A pattern whose prefix can't be determined safely gets the empty prefix, which
+means it is tried for every path, exactly where stock Django would try it. That
+is the case for:
+
+- lazily translated routes (``path(gettext_lazy('about/'), ...)``)
+- regexes that aren't anchored with ``^``, or that contain ``|``
+- ``i18n_patterns`` (``LocalePrefixPattern``)
+- ``URLPattern``/``URLResolver`` subclasses that override ``resolve()``
+- pattern classes it doesn't know
+
+Only the leading literal part of a regex counts: ``r'^ab?c/'`` has the prefix
+``'a'``.
+
+
+Differences from stock Django
+-----------------------------
+
+``tried`` (on ``Resolver404`` and on ``ResolverMatch.tried``) only lists the
+patterns that were actually tried, not every pattern before the match.
+
+With ``DEBUG = True`` a 404 is resolved again the stock way, so the 404 debug
+page lists every pattern as usual. That also acts as a self check: if stock
+Django finds a match where django-fastresolve didn't, you get an
+``AssertionError`` saying so, instead of a wrong 404. Please report it if that
+happens.
+
+The index for a resolver is built on first use. If you append to or remove from
+``urlpatterns`` afterwards the index is rebuilt; replacing an item in place is
+not noticed.
+
+To resolve the stock way for a block of code, in the current context only:
+
+.. code-block:: python
+
+    from django_fastresolve import stock_resolving
+
+    with stock_resolving():
+        match = resolve('/some/path/')
+
+
+Running the tests
+-----------------
+
+.. code-block::
+
+    uv run pytest
+
+The tests resolve a urlconf full of edge cases, plus a few thousand fuzzed
+paths, both ways, and assert identical results.

django_fastresolve-0.1.0/README.rst

@@ -0,0 +1,102 @@
+django-fastresolve
+==================
+
+Faster URL resolving for Django, as a drop-in. No changes to your urlconfs.
+
+Django resolves a path by trying every pattern of a urlconf in order, recursing
+into includes. With a few hundred patterns at one level, every request pays for
+a few hundred regex searches or string compares, and a 404 pays for all of them.
+
+django-fastresolve indexes the patterns of each resolver on their *literal
+prefix*: the text a path must start with for the pattern to have any chance of
+matching (``'projects/'`` for ``path('projects/<int:pk>/', ...)``, ``'blog/'``
+for ``re_path(r'^blog/(?P<slug>\w+)/$', ...)``). A path then only tries the
+patterns whose prefix it starts with, still in their original order. All the
+matching itself is still Django's own code: converters, a ``to_python`` raising
+``ValueError`` falling through to later patterns, namespaces, default kwargs.
+
+
+Installation
+------------
+
+.. code-block::
+
+    pip install django-fastresolve
+
+and add ``'django_fastresolve'`` to ``INSTALLED_APPS``. That's it.
+
+You can also call ``django_fastresolve.install()`` and
+``django_fastresolve.uninstall()`` yourself.
+
+
+How much faster?
+----------------
+
+On a real project with three urlconfs, timing ``resolve()`` on every route,
+with ``DEBUG = False``:
+
+=====================  ======  ============  ==============  ==========  ==========
+urlconf                routes  stock median  fast median     stock 404   fast 404
+=====================  ======  ============  ==============  ==========  ==========
+internal app           785     25 µs         6 µs            27 µs       2 µs
+public site            894     64 µs         4.6 µs          125 µs      4.8 µs
+small                  83      8 µs          7 µs            6 µs        3 µs
+=====================  ======  ============  ==============  ==========  ==========
+
+The more patterns share a level, the bigger the win. Patterns that stock Django
+already finds in the first couple of tries get about 1 µs slower, from the
+index lookup.
+
+
+When does it fall back?
+-----------------------
+
+A pattern whose prefix can't be determined safely gets the empty prefix, which
+means it is tried for every path, exactly where stock Django would try it. That
+is the case for:
+
+- lazily translated routes (``path(gettext_lazy('about/'), ...)``)
+- regexes that aren't anchored with ``^``, or that contain ``|``
+- ``i18n_patterns`` (``LocalePrefixPattern``)
+- ``URLPattern``/``URLResolver`` subclasses that override ``resolve()``
+- pattern classes it doesn't know
+
+Only the leading literal part of a regex counts: ``r'^ab?c/'`` has the prefix
+``'a'``.
+
+
+Differences from stock Django
+-----------------------------
+
+``tried`` (on ``Resolver404`` and on ``ResolverMatch.tried``) only lists the
+patterns that were actually tried, not every pattern before the match.
+
+With ``DEBUG = True`` a 404 is resolved again the stock way, so the 404 debug
+page lists every pattern as usual. That also acts as a self check: if stock
+Django finds a match where django-fastresolve didn't, you get an
+``AssertionError`` saying so, instead of a wrong 404. Please report it if that
+happens.
+
+The index for a resolver is built on first use. If you append to or remove from
+``urlpatterns`` afterwards the index is rebuilt; replacing an item in place is
+not noticed.
+
+To resolve the stock way for a block of code, in the current context only:
+
+.. code-block:: python
+
+    from django_fastresolve import stock_resolving
+
+    with stock_resolving():
+        match = resolve('/some/path/')
+
+
+Running the tests
+-----------------
+
+.. code-block::
+
+    uv run pytest
+
+The tests resolve a urlconf full of edge cases, plus a few thousand fuzzed
+paths, both ways, and assert identical results.

django_fastresolve-0.1.0/django_fastresolve/__init__.py

@@ -0,0 +1,9 @@
+__version__ = '0.1.0'
+
+from django_fastresolve.resolver import (
+    install,
+    stock_resolving,
+    uninstall,
+)
+
+__all__ = ['install', 'stock_resolving', 'uninstall']

django_fastresolve-0.1.0/django_fastresolve/apps.py

@@ -0,0 +1,11 @@
+from django.apps import AppConfig
+
+
+class FastResolveConfig(AppConfig):
+    name = 'django_fastresolve'
+    verbose_name = 'django-fastresolve'
+
+    def ready(self):
+        from django_fastresolve import install
+
+        install()

django_fastresolve-0.1.0/django_fastresolve/resolver.py

@@ -0,0 +1,234 @@
+"""A faster drop-in for ``URLResolver.resolve``.
+
+Django resolves a path by trying every child pattern of a resolver in order,
+and recursing into includes. With hundreds of patterns at one level, that's
+hundreds of regex searches or string compares per request.
+
+This module indexes each resolver's children by their *literal prefix*: the
+part of the pattern that must appear verbatim at the start of the path for the
+pattern to have any chance of matching. A path then only needs to try the
+children whose literal prefix it starts with, still in their original order.
+Everything else (converters, ``ValueError`` from ``to_python`` falling through
+to later patterns, namespaces, default kwargs) is Django's own code.
+
+When the prefix of a child can't be determined safely, its prefix is the empty
+string, meaning it is a candidate for every path. Correctness never depends on
+the index being clever, only on it never excluding a pattern that could match.
+"""
+
+import string
+from contextlib import contextmanager
+from contextvars import ContextVar
+
+from django.conf import settings
+from django.urls.exceptions import Resolver404
+from django.urls.resolvers import (
+    RegexPattern,
+    ResolverMatch,
+    RoutePattern,
+    URLPattern,
+    URLResolver,
+)
+
+stock_resolve = URLResolver.resolve
+
+_use_stock = ContextVar('django_fastresolve_use_stock', default=False)
+
+# Characters that mean themselves when unescaped in a regex, outside a character class
+_REGEX_LITERAL_CHARS = frozenset(string.ascii_letters + string.digits + '/-_~%=,;:@!&\'"<>')
+_REGEX_QUANTIFIER_START = frozenset('?*+{')
+
+
+@contextmanager
+def stock_resolving():
+    """Resolve with Django's own implementation inside this block, in this context only."""
+    token = _use_stock.set(True)
+    try:
+        yield
+    finally:
+        _use_stock.reset(token)
+
+
+def regex_literal_prefix(regex):
+    """The literal text any match of `regex` (searched with `re.search`) must start with.
+
+    Conservative: returns '' whenever the regex isn't plainly ``^literal...``.
+    """
+    if not isinstance(regex, str) or not regex.startswith('^') or '|' in regex:
+        return ''
+
+    prefix = []
+    i = 1
+    while i < len(regex):
+        c = regex[i]
+        if c in _REGEX_LITERAL_CHARS:
+            literal, width = c, 1
+        elif c == '\\' and i + 1 < len(regex) and not regex[i + 1].isalnum():
+            literal, width = regex[i + 1], 2
+        else:
+            break
+
+        i += width
+        if i < len(regex) and regex[i] in _REGEX_QUANTIFIER_START:
+            # The char we just read is optional or repeated, so it's not a fixed prefix
+            break
+        prefix.append(literal)
+
+    return ''.join(prefix)
+
+
+def literal_prefix(url_pattern):
+    """The prefix a path must start with for `url_pattern` to possibly resolve it."""
+    resolve_method = getattr(type(url_pattern), 'resolve', None)
+    if resolve_method is not URLPattern.resolve and resolve_method is not fast_resolve:
+        # A subclass with its own idea of matching, we can't reason about it
+        return ''
+
+    pattern = url_pattern.pattern
+    if type(pattern) is RoutePattern:
+        route = pattern._route
+        if not isinstance(route, str):
+            # Lazily translated, depends on the active language
+            return ''
+        # Cutting at any '<' is safe even when it doesn't start a converter: a shorter prefix only means more candidates
+        index = route.find('<')
+        return route if index == -1 else route[:index]
+
+    if type(pattern) is RegexPattern:
+        return regex_literal_prefix(pattern._regex)
+
+    # LocalePrefixPattern, or a pattern type we don't know
+    return ''
+
+
+class Index:
+    __slots__ = ('patterns', 'length', 'lengths_desc', 'candidates_by_prefix', 'is_root')
+
+    def __init__(self, resolver, patterns):
+        self.patterns = patterns
+        self.length = len(patterns)
+        self.is_root = type(resolver.pattern) is RegexPattern and resolver.pattern._regex == '^/'
+
+        indexes_by_own_prefix = {}
+        for i, url_pattern in enumerate(patterns):
+            indexes_by_own_prefix.setdefault(literal_prefix(url_pattern), []).append(i)
+
+        lengths = sorted({len(prefix) for prefix in indexes_by_own_prefix})
+
+        # For every prefix, the candidates are its own patterns plus those of every
+        # shorter prefix it starts with. Any path's candidates are then those of the
+        # longest prefix it starts with. Shortest first, so parents are done before
+        # their children.
+        indexes_by_prefix = {}
+        for prefix in sorted(indexes_by_own_prefix, key=len):
+            inherited = ()
+            for length in reversed(lengths):
+                if length < len(prefix):
+                    parent = indexes_by_prefix.get(prefix[:length])
+                    if parent is not None:
+                        inherited = parent
+                        break
+            indexes_by_prefix[prefix] = tuple(sorted({*inherited, *indexes_by_own_prefix[prefix]}))
+
+        self.candidates_by_prefix = {prefix: tuple(patterns[i] for i in indexes) for prefix, indexes in indexes_by_prefix.items()}
+        self.lengths_desc = tuple(reversed(lengths))
+
+    def candidates(self, path):
+        candidates_by_prefix = self.candidates_by_prefix
+        path_length = len(path)
+        for length in self.lengths_desc:
+            if length <= path_length:
+                candidates = candidates_by_prefix.get(path[:length])
+                if candidates is not None:
+                    return candidates
+        return ()
+
+
+def _get_index(resolver):
+    patterns = resolver.url_patterns
+    index = resolver.__dict__.get('_fastresolve_index')
+    # The length check catches the common case of urlpatterns being appended to after the first resolve
+    if index is None or index.patterns is not patterns or index.length != len(patterns):
+        if not isinstance(patterns, (list, tuple)):
+            return None
+        index = Index(resolver, patterns)
+        resolver._fastresolve_index = index
+    return index
+
+
+def fast_resolve(self, path):
+    if _use_stock.get():
+        return stock_resolve(self, path)
+
+    path = str(path)  # path may be a reverse_lazy object
+    match = self.pattern.match(path)
+    if not match:
+        raise Resolver404({'path': path})
+
+    index = _get_index(self)
+    if index is None:
+        return stock_resolve(self, path)
+
+    new_path, args, kwargs = match
+    tried = []
+    # From here on, this is Django's URLResolver.resolve, only looping over the candidates instead of all patterns
+    for pattern in index.candidates(new_path):
+        try:
+            sub_match = pattern.resolve(new_path)
+        except Resolver404 as e:
+            self._extend_tried(tried, pattern, e.args[0].get('tried'))
+        else:
+            if sub_match:
+                # Merge captured arguments in match with submatch
+                sub_match_dict = {**kwargs, **self.default_kwargs}
+                # Update the sub_match_dict with the kwargs from the sub_match.
+                sub_match_dict.update(sub_match.kwargs)
+                # If there are *any* named groups, ignore all non-named
+                # groups. Otherwise, pass all non-named arguments as
+                # positional arguments.
+                sub_match_args = sub_match.args
+                if not sub_match_dict:
+                    sub_match_args = args + sub_match.args
+                current_route = '' if isinstance(pattern, URLPattern) else str(pattern.pattern)
+                self._extend_tried(tried, pattern, sub_match.tried)
+                return ResolverMatch(
+                    sub_match.func,
+                    sub_match_args,
+                    sub_match_dict,
+                    sub_match.url_name,
+                    [self.app_name, *sub_match.app_names],
+                    [self.namespace, *sub_match.namespaces],
+                    self._join_route(current_route, sub_match.route),
+                    tried,
+                    captured_kwargs=sub_match.captured_kwargs,
+                    extra_kwargs={
+                        **self.default_kwargs,
+                        **sub_match.extra_kwargs,
+                    },
+                )
+            tried.append([pattern])
+
+    if index.is_root and settings.DEBUG:
+        _check_stock_404(self, path)
+
+    raise Resolver404({'tried': tried, 'path': new_path})
+
+
+def _check_stock_404(resolver, path):
+    """In DEBUG, redo a 404 the stock way.
+
+    The 404 debug page then lists every pattern instead of only the candidates,
+    and if stock Django does find a match, that's a bug in this library and we
+    say so loudly instead of serving a wrong 404.
+    """
+    with stock_resolving():
+        match = stock_resolve(resolver, path)
+    raise AssertionError(f'django-fastresolve bug: {path!r} resolved to {match._func_path} with stock Django, but not with django-fastresolve. Please report this at https://github.com/boxed/django-fastresolve/issues')
+
+
+def install():
+    URLResolver.resolve = fast_resolve
+
+
+def uninstall():
+    URLResolver.resolve = stock_resolve

django_fastresolve-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "django-fastresolve"
+description = "Faster URL resolving for Django, by indexing url patterns on their literal prefixes"
+readme = "README.rst"
+authors = [{ name = "Anders Hovmöller", email = "boxed@killingar.net" }]
+license = { text = "BSD" }
+requires-python = ">=3.10"
+keywords = ["django", "urls", "performance"]
+dependencies = ["Django >= 4.2"]
+dynamic = ["version"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Django",
+    "Framework :: Django :: 4.2",
+    "Framework :: Django :: 5.2",
+    "Framework :: Django :: 6.0",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: BSD License",
+    "Programming Language :: Python :: 3",
+]
+
+[project.urls]
+Homepage = "https://github.com/boxed/django-fastresolve"
+
+[dependency-groups]
+dev = ["pytest", "pytest-django", "django"]
+
+[tool.hatch.version]
+path = "django_fastresolve/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["django_fastresolve"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--strict-markers -r fEsxXw"
+DJANGO_SETTINGS_MODULE = "tests.settings"
+
+[tool.mutmut]
+source_paths = ["django_fastresolve/"]
+also_copy = ["tests/"]

django_fastresolve-0.1.0/tests/conftest.py

@@ -0,0 +1,17 @@
+import pytest
+from django.urls import clear_url_caches, get_resolver
+from django.urls.resolvers import URLResolver
+
+
+def _drop_indexes(resolver):
+    resolver.__dict__.pop('_fastresolve_index', None)
+    for pattern in resolver.url_patterns:
+        if isinstance(pattern, URLResolver):
+            _drop_indexes(pattern)
+
+
+@pytest.fixture(autouse=True)
+def fresh_index():
+    """Build indexes inside each test, so every test that depends on them exercises the indexing code."""
+    _drop_indexes(get_resolver())
+    clear_url_caches()

django_fastresolve-0.1.0/tests/settings.py

@@ -0,0 +1,8 @@
+SECRET_KEY = 'tests'
+DEBUG = False
+INSTALLED_APPS = ['django_fastresolve']
+ROOT_URLCONF = 'tests.urls'
+USE_I18N = True
+LANGUAGE_CODE = 'en'
+LANGUAGES = [('en', 'English'), ('sv', 'Swedish')]
+DATABASES = {}

django_fastresolve-0.1.0/tests/test_resolver.py

@@ -0,0 +1,358 @@
+import random
+import re
+from types import SimpleNamespace
+
+import pytest
+from django.test import override_settings
+from django.urls import (
+    Resolver404,
+    clear_url_caches,
+    get_resolver,
+    path,
+)
+from django.urls.resolvers import (
+    RegexPattern,
+    URLResolver,
+)
+from django.utils import translation
+
+from django_fastresolve import stock_resolving
+from django_fastresolve.resolver import (
+    fast_resolve,
+    install,
+    literal_prefix,
+    regex_literal_prefix,
+    stock_resolve,
+    uninstall,
+)
+from tests import urls
+from tests.urls import make_view
+
+SAMPLE_BY_CONVERTER = {
+    'int': ['0', '7', '12'],
+    'even': ['4', '5'],
+    'str': ['abc', 'a-b'],
+    'slug': ['some-slug'],
+    'path': ['x/y.txt', 'x'],
+}
+
+FIXED_PATHS = [
+    '/',
+    '',
+    'no-leading-slash/',
+    '/even/4/',
+    '/even/5/',
+    '/even/x/',
+    '/literal/',
+    '/literal',
+    '/literal/x/',
+    '/lit',
+    '/lit/',
+    '/literally/',
+    '/foo-offer-12/',
+    '/foo-bar-offer-12/',
+    '/-offer-12/',
+    '/files/a/b/c.txt',
+    '/files/',
+    '/a<b/',
+    '/nested/',
+    '/nested/detail/3/',
+    '/nested/re/12/',
+    '/ns/detail/3/',
+    '/ns2/5/detail/3/',
+    '/ns2/5/',
+    '/kw/',
+    '/kw/detail/9/',
+    '/kwleaf/',
+    '/emptyprefix/',
+    '/deep/a/b/4/',
+    '/deep/a/c/',
+    '/deep/a/b/x/',
+    '/re-anchored/2026/',
+    '/re-anchored/26/',
+    '/re-pos/12/abc/',
+    '/unanchored/',
+    '/foo/bar/unanchored/',
+    '/anywhere/',
+    '/foo/bar/anywhere/baz',
+    '/abc/',
+    '/ac/',
+    '/abbc/',
+    '/xyyz/',
+    '/xyz/',
+    '/alt/',
+    '/other/',
+    '/esc.dot/',
+    '/escxdot/',
+    '/anyxchar/',
+    '/any.char/',
+    '/case/',
+    '/CASE/',
+    '/re-include/detail/1/',
+    '/re-pos-include/7/re/12/',
+    '/translated/',
+    '/nope/',
+    '/something/weird/',
+    '/catchall-child/',
+    '/en/i18n/',
+    '/sv/i18n/',
+    '/en/i18n/3/',
+    '/i18n/',
+    '/does/not/exist/',
+]
+
+MATCH_FIELDS = ['func', 'args', 'kwargs', 'url_name', 'app_names', 'namespaces', 'route', 'captured_kwargs', 'extra_kwargs', 'view_name', '_func_path']
+
+
+def outcome(path_to_resolve, resolve):
+    try:
+        match = resolve(path_to_resolve)
+    except Resolver404 as e:
+        return ('404', e.args[0].get('path'))
+    return tuple(getattr(match, field) for field in MATCH_FIELDS)
+
+
+def fast(path_to_resolve):
+    return get_resolver().resolve(path_to_resolve)
+
+
+def stock(path_to_resolve):
+    with stock_resolving():
+        return get_resolver().resolve(path_to_resolve)
+
+
+def assert_same(path_to_resolve):
+    assert outcome(path_to_resolve, fast) == outcome(path_to_resolve, stock), path_to_resolve
+
+
+def test_installed_by_the_app_config():
+    assert URLResolver.resolve is fast_resolve
+
+
+@pytest.mark.parametrize('language', ['en', 'sv'])
+@pytest.mark.parametrize('path_to_resolve', FIXED_PATHS)
+def test_same_as_stock(path_to_resolve, language):
+    with translation.override(language):
+        assert_same(path_to_resolve)
+
+
+def test_fixed_paths_cover_matches_and_misses():
+    outcomes = [outcome(p, fast) for p in FIXED_PATHS]
+    assert sum(o[0] == '404' for o in outcomes) >= 10
+    assert len({o[0] for o in outcomes if o[0] != '404'}) >= 30
+
+
+def test_converter_value_error_falls_through_to_the_next_pattern():
+    assert fast('/even/4/').func.__name__ == 'even'
+    assert fast('/even/5/').func.__name__ == 'odd_fallback'
+
+
+def test_unanchored_regex_matches_anywhere():
+    assert fast('/foo/bar/anywhere/baz').func.__name__ == 're_anywhere'
+    assert fast('/unanchored/').func.__name__ == 're_unanchored_fullmatch'
+    with pytest.raises(Resolver404):
+        fast('/foo/bar/unanchored/')
+
+
+def test_pattern_subclass_with_own_resolve_is_always_tried():
+    assert fast('/something/weird/').func.__name__ == 'weird'
+
+
+def leaf_samples(patterns, prefix=''):
+    """Concrete paths for every leaf route, built from its route string."""
+    param_re = re.compile(r'<(?:(?P<converter>[^>:]+):)?(?P<name>[^>]+)>')
+    for p in patterns:
+        route = str(p.pattern)
+        if hasattr(p.pattern, '_route'):
+            parts = ['']
+            last = 0
+            for m in param_re.finditer(route):
+                parts = [x + route[last : m.start()] + sample for x in parts for sample in SAMPLE_BY_CONVERTER[m['converter'] or 'str']]
+                last = m.end()
+            parts = [x + route[last:] for x in parts]
+        else:
+            parts = [re.sub(r'[\^$\\]', '', route)]
+        for part in parts:
+            if isinstance(p, URLResolver):
+                yield from leaf_samples(p.url_patterns, prefix + part)
+            else:
+                yield prefix + part
+
+
+def test_fuzz():
+    rng = random.Random(1337)
+    samples = sorted(set(leaf_samples(urls.urlpatterns)))
+    fragments = sorted({fragment for sample in samples for fragment in re.split('(/)', sample) if fragment}) + ['', 'x', '-', '.', 'en', 'sv']
+    paths = set()
+    for sample in samples:
+        paths.add('/' + sample)
+        for cut in range(len(sample)):
+            paths.add('/' + sample[:cut])
+            paths.add('/' + sample[:cut] + 'x' + sample[cut:])
+        paths.add('/' + sample + 'x')
+        paths.add('/' + sample + 'x/')
+    for _ in range(3000):
+        paths.add('/' + ''.join(rng.choice(fragments) for _ in range(rng.randint(1, 8))))
+
+    for p in sorted(paths):
+        for language in ['en', 'sv']:
+            with translation.override(language):
+                assert_same(p)
+
+
+def test_appending_to_urlpatterns_after_first_resolve():
+    with pytest.raises(Resolver404):
+        fast('/appended/')
+    urls.urlpatterns.append(path('appended/', make_view('appended')))
+    try:
+        assert fast('/appended/').func.__name__ == 'appended'
+    finally:
+        urls.urlpatterns.pop()
+        clear_url_caches()
+
+
+@override_settings(DEBUG=True)
+def test_debug_404_has_the_full_tried_list():
+    with pytest.raises(Resolver404) as fast_404:
+        fast('/does/not/exist/')
+    with pytest.raises(Resolver404) as stock_404:
+        stock('/does/not/exist/')
+    assert len(fast_404.value.args[0]['tried']) == len(stock_404.value.args[0]['tried'])
+    assert len(fast_404.value.args[0]['tried']) > 30
+
+
+@override_settings(DEBUG=True)
+def test_debug_404_that_stock_django_resolves_is_reported_as_a_bug(monkeypatch):
+    from django_fastresolve import resolver
+
+    monkeypatch.setattr(resolver.Index, 'candidates', lambda self, path: ())
+    clear_url_caches()
+    with pytest.raises(AssertionError, match='django-fastresolve bug'):
+        fast('/literal/')
+    clear_url_caches()
+
+
+def test_tried_on_404_without_debug_only_has_candidates():
+    with pytest.raises(Resolver404) as e:
+        fast('/does/not/exist/')
+    assert len(e.value.args[0]['tried']) < 15
+
+
+@pytest.mark.parametrize(
+    'regex, expected',
+    [
+        (r'^foo/$', 'foo/'),
+        (r'^foo/(?P<x>\d+)/$', 'foo/'),
+        (r'foo/$', ''),
+        (r'^ab?c/', 'a'),
+        (r'^ab*c/', 'a'),
+        (r'^ab+c/', 'a'),
+        (r'^xy{2}z/', 'x'),
+        (r'^esc\.dot/', 'esc.dot/'),
+        (r'^esc\.?dot/', 'esc'),
+        (r'^\d+/', ''),
+        (r'^a.b/', 'a'),
+        (r'^a[bc]/', 'a'),
+        (r'^a|b', ''),
+        (r'(?i)^case/', ''),
+        (r'^', ''),
+        (r'^/', '/'),
+        (r'^a(b)/', 'a'),
+        (r'^a$', 'a'),
+    ],
+)
+def test_regex_literal_prefix(regex, expected):
+    assert regex_literal_prefix(regex) == expected
+
+
+@pytest.mark.parametrize(
+    'regex, expected',
+    [
+        (r'^esc\.', 'esc.'),
+        ('^a\\', 'a'),
+    ],
+)
+def test_regex_literal_prefix_escape_at_end(regex, expected):
+    assert regex_literal_prefix(regex) == expected
+
+
+@pytest.mark.parametrize(
+    'route, expected',
+    [
+        ('literal/', 'literal/'),
+        ('a<int:x>/', 'a'),
+        ('foo/<int:x>/', 'foo/'),
+        ('<int:x>/', ''),
+    ],
+)
+def test_literal_prefix_of_route(route, expected):
+    assert literal_prefix(path(route, make_view('v'))) == expected
+
+
+def is_subsequence(needle, haystack):
+    it = iter(haystack)
+    return all(any(x == y for y in it) for x in needle)
+
+
+def tried_routes(tried):
+    return [[str(p.pattern) for p in entry] for entry in tried]
+
+
+@pytest.mark.parametrize('path_to_resolve', ['/nested/nope/', '/deep/a/b/x/', '/ns2/5/nope/'])
+def test_tried_on_404_is_a_subsequence_of_stock(path_to_resolve):
+    with pytest.raises(Resolver404) as fast_404:
+        fast(path_to_resolve)
+    with pytest.raises(Resolver404) as stock_404:
+        stock(path_to_resolve)
+    fast_tried = tried_routes(fast_404.value.args[0]['tried'])
+    assert any(len(entry) > 1 for entry in fast_tried)
+    assert is_subsequence(fast_tried, tried_routes(stock_404.value.args[0]['tried']))
+
+
+@pytest.mark.parametrize('path_to_resolve', ['/literal/', '/nested/detail/3/', '/deep/a/b/4/', '/even/5/'])
+def test_tried_on_match_is_a_subsequence_of_stock(path_to_resolve):
+    fast_tried = tried_routes(fast(path_to_resolve).tried)
+    stock_tried = tried_routes(stock(path_to_resolve).tried)
+    assert fast_tried[-1] == stock_tried[-1]
+    assert is_subsequence(fast_tried, stock_tried)
+
+
+def test_index_is_reused_and_rebuilt_when_patterns_are_replaced():
+    resolver = get_resolver()
+    fast('/literal/')
+    index = resolver._fastresolve_index
+    fast('/literal/')
+    assert resolver._fastresolve_index is index
+
+    resolver.url_patterns = [*resolver.url_patterns[:-1], path('replaced/', make_view('replaced'))]
+    try:
+        assert fast('/replaced/').func.__name__ == 'replaced'
+        assert resolver._fastresolve_index is not index
+    finally:
+        clear_url_caches()
+
+
+class PatternSequence:
+    """url patterns that are iterable, but neither a list nor a tuple."""
+
+    def __init__(self, patterns):
+        self.patterns = patterns
+
+    def __iter__(self):
+        return iter(self.patterns)
+
+
+def test_patterns_that_are_not_a_list_fall_back_to_stock():
+    resolver = URLResolver(RegexPattern(r'^/'), SimpleNamespace(urlpatterns=PatternSequence([path('x/', make_view('x'))])))
+    assert resolver.resolve('/x/').func.__name__ == 'x'
+    with pytest.raises(Resolver404):
+        resolver.resolve('/y/')
+
+
+def test_uninstall_and_install():
+    uninstall()
+    try:
+        assert URLResolver.resolve is stock_resolve
+    finally:
+        install()
+    assert URLResolver.resolve is fast_resolve

django_fastresolve-0.1.0/tests/urls.py

@@ -0,0 +1,98 @@
+"""A urlconf full of edge cases. Every test resolves against it both the stock way and the fast way."""
+
+from django.conf.urls.i18n import i18n_patterns
+from django.urls import (
+    include,
+    path,
+    re_path,
+    register_converter,
+)
+from django.urls.resolvers import (
+    ResolverMatch,
+    RoutePattern,
+    URLPattern,
+)
+from django.utils.translation import gettext_lazy
+
+
+def make_view(name):
+    def view(request, *args, **kwargs):
+        pass  # pragma: no cover
+
+    view.__name__ = view.__qualname__ = name
+    return view
+
+
+class EvenConverter:
+    regex = '[0-9]+'
+
+    def to_python(self, value):
+        if int(value) % 2:
+            raise ValueError()
+        return int(value)
+
+    def to_url(self, value):
+        return str(value)  # pragma: no cover
+
+
+register_converter(EvenConverter, 'even')
+
+
+class MatchesEverythingEndingInWeird(URLPattern):
+    """A subclass with its own resolve: its pattern says nothing about what it matches."""
+
+    def resolve(self, path):
+        if path.endswith('/weird/'):
+            return ResolverMatch(self.callback, (), {}, 'weird', route=str(self.pattern), captured_kwargs={}, extra_kwargs={})
+
+
+inner = [
+    path('', make_view('inner_index'), name='inner_index'),
+    path('detail/<int:pk>/', make_view('inner_detail'), name='inner_detail'),
+    re_path(r'^re/(\d+)/$', make_view('inner_re_positional')),
+]
+
+urlpatterns = [
+    path('', make_view('index'), name='index'),
+    # The even converter raises ValueError on odd numbers, and the next pattern must get its turn
+    path('even/<even:n>/', make_view('even')),
+    path('even/<int:n>/', make_view('odd_fallback')),
+    path('literal/', make_view('literal'), name='literal'),
+    path('literal/', make_view('literal_shadowed')),
+    path('lit', make_view('lit_no_slash')),
+    path('literally/', make_view('literally')),
+    path('<slug:slug>-offer-<int:pk>/', make_view('slug_offer')),
+    path('files/<path:file_path>', make_view('files')),
+    path('a<b/', make_view('angle_bracket_without_converter')),
+    path('nested/', include(inner)),
+    path('ns/', include((inner, 'app'), namespace='ns1')),
+    path('ns2/<int:outer>/', include((inner, 'app'), namespace='ns2')),
+    path('kw/', include(inner), {'extra': 1}),
+    path('kwleaf/', make_view('kwleaf'), {'a': 1}),
+    path('', include([path('emptyprefix/', make_view('emptyprefix'))])),
+    path('deep/', include([path('a/', include([path('b/', include([path('<int:x>/', make_view('deep'))]))]))])),
+    path('deep/a/', include([path('c/', make_view('deep_c'))])),
+    re_path(r'^re-anchored/(?P<year>[0-9]{4})/$', make_view('re_named')),
+    re_path(r'^re-pos/([0-9]+)/([a-z]+)/$', make_view('re_pos')),
+    # Ends in $, so Django uses fullmatch: anchored after all
+    re_path(r'unanchored/$', make_view('re_unanchored_fullmatch')),
+    # Not anchored and no $: re.search finds this anywhere in the path
+    re_path(r'anywhere/', make_view('re_anywhere')),
+    re_path(r'^ab?c/$', make_view('re_quantifier')),
+    re_path(r'^xy{2}z/$', make_view('re_brace_quantifier')),
+    re_path(r'^alt/$|^other/$', make_view('re_alternation')),
+    re_path(r'^esc\.dot/$', make_view('re_escaped')),
+    re_path(r'^any.char/$', make_view('re_dot')),
+    re_path(r'(?i)^case/$', make_view('re_case_insensitive')),
+    re_path(r'^re-include/', include(inner)),
+    # Positional args from the include and the leaf are concatenated
+    re_path(r'^re-pos-include/([0-9]+)/', include(inner)),
+    path(gettext_lazy('translated/'), make_view('translated')),
+    MatchesEverythingEndingInWeird(RoutePattern('nope/', is_endpoint=True), make_view('weird')),
+    re_path(r'^', include([path('catchall-child/', make_view('catchall_child'))])),
+]
+
+urlpatterns += i18n_patterns(
+    path('i18n/', make_view('i18n')),
+    path('i18n/<int:pk>/', make_view('i18n_pk')),
+)

django_fastresolve-0.1.0/uv.lock

@@ -0,0 +1,247 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+resolution-markers = [
+    "python_full_version >= '3.12'",
+    "python_full_version < '3.12'",
+]
+
+[[package]]
+name = "asgiref"
+version = "3.12.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e6/26/3b59f2bdae5f640389becb1f673cded775287f5fc4f816309d9ca9a3f93d/asgiref-3.12.1.tar.gz", hash = "sha256:59dcb51c272ad209d59bed5708a64a333083e86017d7fcdd67498eeab7784340", size = 42378, upload-time = "2026-07-14T09:56:18.087Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/1b/54f4ad77cd8a584fa70746c47df988e002cf1ee1eba43364d46f87803647/asgiref-3.12.1-py3-none-any.whl", hash = "sha256:fe386d1c2bff7259ea95929266d12a8cf9a8b5a1c2598402967d8792e7a7c094", size = 25478, upload-time = "2026-07-14T09:56:16.926Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "django"
+version = "5.2.17"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.12'",
+]
+dependencies = [
+    { name = "asgiref", marker = "python_full_version < '3.12'" },
+    { name = "sqlparse", marker = "python_full_version < '3.12'" },
+    { name = "tzdata", marker = "python_full_version < '3.12' and sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d5/d8/43e9d000519adceb189620b6869ff88031e046df91c2e9da72f8f6918399/django-5.2.17.tar.gz", hash = "sha256:9d4d93be539a18ab80d058eb515900e10951e04c537c5a6b394fc49528d3251f", size = 10889740, upload-time = "2026-08-04T15:04:03.173Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/f8/ce120525ca78f12b07daf65786679c5d0b54a75285a8958d3ae55e39da35/django-5.2.17-py3-none-any.whl", hash = "sha256:f04fb3b36ee119e1af4fa1d397d5fd6cf12700f49321e84d4f4c642c5b1973db", size = 8315563, upload-time = "2026-08-04T15:03:59.1Z" },
+]
+
+[[package]]
+name = "django"
+version = "6.1.1"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.12'",
+]
+dependencies = [
+    { name = "asgiref", marker = "python_full_version >= '3.12'" },
+    { name = "sqlparse", marker = "python_full_version >= '3.12'" },
+    { name = "tzdata", marker = "python_full_version >= '3.12' and sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f8/d4/8314b5bdef20832f0ac6ae3b3e4d4924e4759fa3b4af27609dd747e7a6be/django-6.1.1.tar.gz", hash = "sha256:7ab93536d8e677aa14554c56426290c69480bf2ee68d7513d4a22f57d6bfeb84", size = 11284905, upload-time = "2026-09-02T17:20:45.621Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/ca/c1040a4fd15754ede7df15fd72fc2e123045b473b253ab5f5284e11c651e/django-6.1.1-py3-none-any.whl", hash = "sha256:585fb82bf15053c42cf52e67c2f1b54a032dca384759315fd6678ab1870d1d72", size = 8419512, upload-time = "2026-09-02T17:20:39.153Z" },
+]
+
+[[package]]
+name = "django-fastresolve"
+source = { editable = "." }
+dependencies = [
+    { name = "django", version = "5.2.17", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "django", version = "6.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "django", version = "5.2.17", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" },
+    { name = "django", version = "6.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" },
+    { name = "pytest" },
+    { name = "pytest-django" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "django", specifier = ">=4.2" }]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "django" },
+    { name = "pytest" },
+    { name = "pytest-django" },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-django"
+version = "4.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/44/f6/3851312120c2bf2f19cafff931e75059aad1ba670703cd751e2fde9bc942/pytest_django-4.14.0.tar.gz", hash = "sha256:26787dd3f422cfbab8f55b80a776e2edea7a11092cb74e960bef1312515708ef", size = 94700, upload-time = "2026-08-10T14:13:08.319Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9c/03/850bffad2b581c440ca51c039d74504d5a422c94bda0bdb8a8ba5068d48b/pytest_django-4.14.0-py3-none-any.whl", hash = "sha256:c533b08d89cc675efcd5398eea270b34547e35f9a3608e2c9748dd88428ea187", size = 27067, upload-time = "2026-08-10T14:13:06.998Z" },
+]
+
+[[package]]
+name = "sqlparse"
+version = "0.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/d3/3f06a1006f2261d1342aefb3c71eed02f5d4ca5bdbecd86ebc12ad38306e/sqlparse-0.6.0.tar.gz", hash = "sha256:113c35c75365ab9cc9c7231d68c6428fb11c085fc8e9eb1ad659b7ddbf6cd2b9", size = 178477, upload-time = "2026-08-13T19:16:06.396Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/50/f00935da0ec7cbf325f8dc4f772ae46fbc7b672dd62876e73f0a94adda57/sqlparse-0.6.0-py3-none-any.whl", hash = "sha256:b861c0288ce2fa56209a9a6412d2e066ac664b3873b89c26c9d8415e8e32996f", size = 50070, upload-time = "2026-08-13T19:16:04.062Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+    { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" },
+    { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" },
+    { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" },
+    { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" },
+    { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" },
+    { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" },
+    { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" },
+    { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" },
+    { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" },
+    { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" },
+    { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" },
+    { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" },
+    { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" },
+    { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" },
+    { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" },
+    { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[package]]
+name = "tzdata"
+version = "2026.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e4/31/3d74fa778a63b98b7374323befcc0be5ab3bd94afd4096a0124e7379152c/tzdata-2026.4.tar.gz", hash = "sha256:f1b8bd365d8d210c55353f4d7f8d6d8561c0ba50d704b700d195a9424bba0d79", size = 199350, upload-time = "2026-09-12T12:56:03.251Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/bc/8737e8d54cf51106118039b83f485a4783112fab49ea9d044b234978a46e/tzdata-2026.4-py2.py3-none-any.whl", hash = "sha256:c2169a8b0a7a5e9674da5a135ccdfb2b3e671b333ed9fed17b41f73c34476e81", size = 347494, upload-time = "2026-09-12T12:56:01.67Z" },
+]