Replace threading.local() with ContextVar for async compatibility

threading.local() doesn't propagate across asyncio.to_thread() boundaries,
so per-request state like timezone activation would be lost when sync views
run in the executor. ContextVar propagates correctly through both
asyncio.to_thread() and asyncio.create_task().

- timezone.py: _active uses ContextVar with token-based reset in override
- resolvers.py: recursion guard uses module-level ContextVar[frozenset[int]]

Author: davegaeddert

plain/plain/urls/resolvers.py

@@ -10,7 +10,7 @@
 
 import functools
 import re
-from threading import local
+from contextvars import ContextVar
 from typing import TYPE_CHECKING, Any
 from urllib.parse import quote
 
@@ -23,6 +23,10 @@
 from .exceptions import NoReverseMatch, Resolver404
 from .patterns import RegexPattern, RoutePattern, URLPattern
 
+# Tracks which URLResolver instances are currently inside _populate(),
+# to prevent infinite recursion when resolvers reference each other.
+_populating: ContextVar[frozenset[int]] = ContextVar("_populating", default=frozenset())
+
 if TYPE_CHECKING:
     from plain.preflight import PreflightResult
 
@@ -111,7 +115,6 @@ def __init__(
         self._reverse_dict: MultiValueDict = MultiValueDict()
         self._namespace_dict: dict[str, tuple[str, URLResolver]] = {}
         self._populated = False
-        self._local = local()
 
         # Set these immediately, in part so we can find routers
         # where the attributes weren't set correctly.
@@ -129,14 +132,15 @@ def preflight(self) -> list[PreflightResult]:
         return messages
 
     def _populate(self) -> None:
-        # Short-circuit if called recursively in this thread to prevent
-        # infinite recursion. Concurrent threads may call this at the same
-        # time and will need to continue, so set 'populating' on a
-        # thread-local variable.
-        if getattr(self._local, "populating", False):
+        # Short-circuit if called recursively in this context to prevent
+        # infinite recursion. Concurrent contexts may call this at the same
+        # time and will need to continue, so track populating resolvers in a
+        # context variable.
+        current = _populating.get()
+        if id(self) in current:
             return
+        token = _populating.set(current | {id(self)})
         try:
-            self._local.populating = True
             lookups = MultiValueDict()
             namespaces = {}
             for url_pattern in reversed(self.url_patterns):
@@ -196,7 +200,7 @@ def _populate(self) -> None:
             self._reverse_dict = lookups
             self._populated = True
         finally:
-            self._local.populating = False
+            _populating.reset(token)
 
     @property
     def reverse_dict(self) -> MultiValueDict:

plain/plain/utils/timezone.py

@@ -7,8 +7,8 @@
 import functools
 import zoneinfo
 from contextlib import ContextDecorator
+from contextvars import ContextVar
 from datetime import UTC, datetime, time, timedelta, timezone, tzinfo
-from threading import local
 from types import TracebackType
 
 from plain.runtime import settings
@@ -59,12 +59,13 @@ def get_default_timezone_name() -> str:
     return _get_timezone_name(get_default_timezone())
 
 
-_active = local()
+_active: ContextVar[tzinfo | None] = ContextVar("_active", default=None)
 
 
 def get_current_timezone() -> tzinfo:
     """Return the currently active time zone as a tzinfo instance."""
-    return getattr(_active, "value", get_default_timezone())
+    tz = _active.get()
+    return tz if tz is not None else get_default_timezone()
 
 
 def get_current_timezone_name() -> str:
@@ -88,32 +89,31 @@ def _get_timezone_name(timezone: tzinfo) -> str:
 
 def activate(timezone: tzinfo | str) -> None:
     """
-    Set the time zone for the current thread.
+    Set the time zone for the current context.
 
     The ``timezone`` argument must be an instance of a tzinfo subclass or a
     time zone name.
     """
     if isinstance(timezone, tzinfo):
-        _active.value = timezone
+        _active.set(timezone)
     elif isinstance(timezone, str):
-        _active.value = zoneinfo.ZoneInfo(timezone)
+        _active.set(zoneinfo.ZoneInfo(timezone))
     else:
         raise ValueError(f"Invalid timezone: {timezone!r}")
 
 
 def deactivate() -> None:
     """
-    Unset the time zone for the current thread.
+    Unset the time zone for the current context.
 
     Plain will then use the time zone defined by settings.TIME_ZONE.
     """
-    if hasattr(_active, "value"):
-        del _active.value
+    _active.set(None)
 
 
 class override(ContextDecorator):
     """
-    Temporarily set the time zone for the current thread.
+    Temporarily set the time zone for the current context.
 
     This is a context manager that uses plain.utils.timezone.activate()
     to set the timezone on entry and restores the previously active timezone
@@ -126,25 +126,22 @@ class override(ContextDecorator):
 
     def __init__(self, timezone: tzinfo | str | None) -> None:
         self.timezone = timezone
-        self.old_timezone: tzinfo | None = None
 
     def __enter__(self) -> None:
-        self.old_timezone = getattr(_active, "value", None)
         if self.timezone is None:
-            deactivate()
+            self._token = _active.set(None)
+        elif isinstance(self.timezone, str):
+            self._token = _active.set(zoneinfo.ZoneInfo(self.timezone))
         else:
-            activate(self.timezone)
+            self._token = _active.set(self.timezone)
 
     def __exit__(
         self,
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
     ) -> None:
-        if self.old_timezone is None:
-            deactivate()
-        else:
-            _active.value = self.old_timezone
+        _active.reset(self._token)
 
 
 # Utilities