feat: Allow alru_cache to automatically clear and rebind to the current event loop on cross-loop access instead of raising a RuntimeError.

Author: rodrigo.nogueira

async_lru/__init__.py

@@ -130,11 +130,10 @@ def _check_loop(self, loop: asyncio.AbstractEventLoop) -> None:
         if self.__first_loop is None:
             self.__first_loop = loop
         elif self.__first_loop is not loop:
-            raise RuntimeError(
-                "alru_cache is not safe to use across event loops: this cache "
-                "instance was first used with a different event loop. "
-                "Use separate cache instances per event loop."
-            )
+            # Old cache entries hold tasks/handles bound to the previous
+            # loop and are invalid here.  Clear and rebind.
+            self.cache_clear()
+            self.__first_loop = loop
 
     def cache_invalidate(self, /, *args: Hashable, **kwargs: Any) -> bool:
         key = _make_key(args, kwargs, self.__typed)
@@ -156,8 +155,6 @@ def cache_clear(self) -> None:
         self.__cache.clear()
 
     async def cache_close(self, *, wait: bool = False) -> None:
-        loop = asyncio.get_running_loop()
-        self._check_loop(loop)
         self.__closed = True
 
         tasks = self.__tasks
@@ -236,9 +233,10 @@ async def __call__(self, /, *fn_args: Any, **fn_kwargs: Any) -> _R:
             raise RuntimeError(f"alru_cache is closed for {self}")
 
         loop = asyncio.get_running_loop()
+        self._check_loop(loop)
+
         key = _make_key(fn_args, fn_kwargs, self.__typed)
         cache_item = self.__cache.get(key)
-        self._check_loop(loop)
 
         if cache_item is not None:
             self._cache_hit(key)

tests/test_thread_safety.py

@@ -3,7 +3,7 @@
 from async_lru import alru_cache
 
 
-def test_cross_loop_access_raises_error() -> None:
+def test_cross_loop_auto_resets_cache() -> None:
     @alru_cache(maxsize=100)
     async def cached_func(key: str) -> str:
         return f"data_{key}"
@@ -12,19 +12,39 @@ async def cached_func(key: str) -> str:
     loop1.run_until_complete(cached_func("test"))
     loop1.close()
 
+    assert cached_func.cache_info().currsize == 1
+
     loop2 = asyncio.new_event_loop()
-    error_raised = False
-    error_message = ""
-    try:
-        loop2.run_until_complete(cached_func("test"))
-    except RuntimeError as e:
-        error_raised = True
-        error_message = str(e)
-    finally:
-        loop2.close()
+    result = loop2.run_until_complete(cached_func("test"))
+    loop2.close()
+
+    assert result == "data_test"
+    # Cache was cleared on loop change, so the old entry is gone.
+    # The new call re-populated it as a miss.
+    assert cached_func.cache_info().hits == 0
+    assert cached_func.cache_info().misses == 1
+
 
-    assert error_raised, "RuntimeError should be raised for cross-loop access"
-    assert "event loop" in error_message.lower()
+def test_cross_loop_preserves_stats_reset() -> None:
+    @alru_cache(maxsize=100)
+    async def cached_func(key: str) -> str:
+        return f"data_{key}"
+
+    loop1 = asyncio.new_event_loop()
+    loop1.run_until_complete(cached_func("a"))
+    loop1.run_until_complete(cached_func("a"))
+    loop1.close()
+
+    assert cached_func.cache_info().hits == 1
+    assert cached_func.cache_info().misses == 1
+
+    loop2 = asyncio.new_event_loop()
+    loop2.run_until_complete(cached_func("a"))
+    loop2.close()
+
+    # Stats were reset on loop change (cache_clear resets hits/misses)
+    assert cached_func.cache_info().hits == 0
+    assert cached_func.cache_info().misses == 1
 
 
 def test_invalid_key_does_not_bind_loop() -> None:
@@ -72,7 +92,7 @@ async def run_test() -> list[str]:
     assert cached_func.cache_info().hits == 1
 
 
-def test_cross_loop_cache_close_raises_error() -> None:
+def test_cross_loop_cache_close_works() -> None:
     @alru_cache(maxsize=100)
     async def cached_func(key: str) -> str:
         return f"data_{key}"
@@ -82,15 +102,8 @@ async def cached_func(key: str) -> str:
     loop1.close()
 
     loop2 = asyncio.new_event_loop()
-    error_raised = False
-    try:
-        loop2.run_until_complete(cached_func.cache_close())
-    except RuntimeError:
-        error_raised = True
-    finally:
-        loop2.close()
-
-    assert error_raised, "RuntimeError should be raised for cross-loop cache_close"
+    loop2.run_until_complete(cached_func.cache_close())
+    loop2.close()
 
 
 def test_sync_methods_work_without_loop_check() -> None:
@@ -125,3 +138,15 @@ async def run_concurrent() -> list[str]:
 
     assert results == ["data_test"] * 3
     assert cached_func.cache_info().hits == 2
+
+
+def test_multiple_loop_transitions() -> None:
+    @alru_cache(maxsize=100)
+    async def cached_func(key: str) -> str:
+        return f"data_{key}"
+
+    for i in range(5):
+        loop = asyncio.new_event_loop()
+        result = loop.run_until_complete(cached_func("test"))
+        loop.close()
+        assert result == "data_test"