simple-dep-cache 0.2.0__tar.gz → 0.3.0__tar.gz

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/.github/workflows/test.yml

@@ -10,6 +10,11 @@ jobs:
   test:
     runs-on: ubuntu-latest
 
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+
     steps:
     - uses: actions/checkout@v5
 
@@ -17,6 +22,7 @@ jobs:
       uses: astral-sh/setup-uv@v6
       with:
         version: "latest"
+        python-version: ${{ matrix.python-version }}
 
     - name: Install dependencies
       run: uv sync --all-extras

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project will be documented in this file.
 
+## v0.3.0 - 2026-06-23
+
+### Added
+
+- **Async event callbacks**: event callbacks registered via `on_event` /
+  `on_all_events` may now be coroutine functions. The async cache methods
+  (`aset`, `aget`, `adelete`, `aclear`, `ainvalidate_dependency`) dispatch to
+  both sync and async callbacks, awaiting the async ones.
+  - New `EventEmitter.aemit()` awaits async callbacks; `emit()` runs only sync
+    callbacks (it never leaves a coroutine un-awaited).
+  - New `EventEmitter.has_async_callbacks(event_type)`.
+  - Callback type hints widened to `CacheCallback = Callable[[CacheEvent], Any]`.
+
+### Changed
+
+- A **synchronous** cache operation (`set`/`get`/`delete`/`clear`/
+  `invalidate_dependency`) now raises `RuntimeError` if an async callback is
+  registered for the emitted event, instead of silently dropping it. Use the
+  async (`a`-prefixed) methods to dispatch async callbacks. Sync callbacks are
+  unaffected.
+
 ## v0.1.3 - 2025-09-19
 
 ### Added

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple-dep-cache
-Version: 0.2.0
+Version: 0.3.0
 Summary: Redis-based caching library with intelligent dependency tracking for Python applications
 Project-URL: Homepage, https://github.com/tintty1/simple-dep-cache
 Project-URL: Repository, https://github.com/tintty1/simple-dep-cache
@@ -543,6 +543,36 @@ async def async_function(x):
 
 Callback exceptions are caught and logged.
 
+#### Event callbacks (sync & async)
+
+Beyond the decorator `callback`, you can subscribe to manager-level events
+(`SET`, `HIT`, `MISS`, `DELETE`, `INVALIDATE`, `CLEAR`). Callbacks may be sync
+**or** async:
+
+```python
+from simple_dep_cache import CacheEventType, get_or_create_cache_manager
+
+cache = get_or_create_cache_manager()
+
+def on_invalidate(event):                 # sync callback
+    log.info("invalidated %s (%s entries)", event.key, event.count)
+
+async def on_invalidate_async(event):     # async callback
+    await bus.publish("cache.invalidate", {"key": event.key})
+
+cache.on_event(CacheEventType.INVALIDATE, on_invalidate)
+cache.on_event(CacheEventType.INVALIDATE, on_invalidate_async)
+```
+
+- Async callbacks are awaited by the **async** cache methods (`aset`, `aget`,
+  `adelete`, `aclear`, `ainvalidate_dependency`) via `EventEmitter.aemit()`.
+- The **sync** methods only dispatch sync callbacks. If an async callback is
+  registered for an event a sync method emits, that method raises
+  `RuntimeError` (a sync context can't await it) — use the async method, or a
+  sync callback.
+- A single sync callback also runs from the async methods, so it's the simplest
+  choice when you don't need to `await` inside the callback.
+
 **Decorators:**
 
 - `@cache_with_deps(name, ttl, dependencies, cache_exception_types, callback)` - Works for both sync and async functions

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/README.md

@@ -521,6 +521,36 @@ async def async_function(x):
 
 Callback exceptions are caught and logged.
 
+#### Event callbacks (sync & async)
+
+Beyond the decorator `callback`, you can subscribe to manager-level events
+(`SET`, `HIT`, `MISS`, `DELETE`, `INVALIDATE`, `CLEAR`). Callbacks may be sync
+**or** async:
+
+```python
+from simple_dep_cache import CacheEventType, get_or_create_cache_manager
+
+cache = get_or_create_cache_manager()
+
+def on_invalidate(event):                 # sync callback
+    log.info("invalidated %s (%s entries)", event.key, event.count)
+
+async def on_invalidate_async(event):     # async callback
+    await bus.publish("cache.invalidate", {"key": event.key})
+
+cache.on_event(CacheEventType.INVALIDATE, on_invalidate)
+cache.on_event(CacheEventType.INVALIDATE, on_invalidate_async)
+```
+
+- Async callbacks are awaited by the **async** cache methods (`aset`, `aget`,
+  `adelete`, `aclear`, `ainvalidate_dependency`) via `EventEmitter.aemit()`.
+- The **sync** methods only dispatch sync callbacks. If an async callback is
+  registered for an event a sync method emits, that method raises
+  `RuntimeError` (a sync context can't await it) — use the async method, or a
+  sync callback.
+- A single sync callback also runs from the async methods, so it's the simplest
+  choice when you don't need to `await` inside the callback.
+
 **Decorators:**
 
 - `@cache_with_deps(name, ttl, dependencies, cache_exception_types, callback)` - Works for both sync and async functions

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/src/simple_dep_cache/decorators.py

@@ -1,5 +1,5 @@
-import asyncio
 import hashlib
+import inspect
 import logging
 from collections.abc import Callable
 from functools import wraps
@@ -108,7 +108,7 @@ def _validate_callback_compatibility(
     if callback is None:
         return None
 
-    callback_is_async = asyncio.iscoroutinefunction(callback)
+    callback_is_async = inspect.iscoroutinefunction(callback)
 
     if is_async_function and not callback_is_async:
         # Sync callback with async function is fine
@@ -149,6 +149,32 @@ def _handle_callback_error(error: Exception, cache_manager: CacheManager, contex
         pass
 
 
+def _handle_backend_error(operation: str, func_name: str, error: Exception, silent: bool) -> None:
+    """Handle backend errors by logging or re-raising based on silent flag."""
+    if not silent:
+        raise
+    logger = logging.getLogger(__name__)
+    logger.warning("Backend error during %s for %s: %s", operation, func_name, error, exc_info=True)
+
+
+def _safe_backend_op(op: Callable, silent: bool, func_name: str, operation: str) -> Any:
+    """Execute a backend operation with optional error silencing."""
+    try:
+        return op()
+    except Exception as e:
+        _handle_backend_error(operation, func_name, e, silent)
+        return None
+
+
+async def _safe_backend_op_async(op: Callable, silent: bool, func_name: str, operation: str) -> Any:
+    """Execute an async backend operation with optional error silencing."""
+    try:
+        return await op()
+    except Exception as e:
+        _handle_backend_error(operation, func_name, e, silent)
+        return None
+
+
 def _cache_result_or_exception_sync(
     cache_manager: CacheManager,
     cache_key: str,
@@ -211,6 +237,7 @@ def cache_with_deps(
     dependencies: set | None = None,
     cache_exception_types: list[type[Exception]] | None = None,
     callback: Callable | None = None,
+    silent_backend_errors: bool = False,
 ) -> Callable:
     """
     Decorator for caching function results with dependency tracking.
@@ -226,10 +253,13 @@ def cache_with_deps(
         callback: Callback function invoked on cache hit or miss.
             Called with keyword arguments: func, cache_manager, args, kwargs, is_hit, cached_result
             is_hit=True for cache hits, False for cache misses (optional)
+        silent_backend_errors: If True, silently log backend errors (e.g., Redis connection errors)
+            instead of raising them. The decorated function will execute normally when backend
+            errors occur. Defaults to False (optional)
     """
 
     def decorator(func: Callable) -> Callable:
-        if asyncio.iscoroutinefunction(func):
+        if inspect.iscoroutinefunction(func):
 
             @wraps(func)
             async def async_wrapper(*args, **kwargs):
@@ -244,14 +274,21 @@ def cache_with_deps(
 
                 cache_key = _generate_cache_key(func, args, kwargs)
 
-                cached_result = await active_cache_manager.aget(cache_key)
+                # Try to get from cache with optional error silencing
+                cached_result = await _safe_backend_op_async(
+                    lambda: active_cache_manager.aget(cache_key),
+                    silent_backend_errors,
+                    func.__qualname__,
+                    "cache get",
+                )
+
                 if cached_result is not None:
                     cache_hit_result = _handle_cache_hit(cached_result)
                     if cache_hit_result is not None:
                         # Invoke callback for cache hit
                         if valid_callback:
                             try:
-                                if asyncio.iscoroutinefunction(valid_callback):
+                                if inspect.iscoroutinefunction(valid_callback):
                                     await valid_callback(
                                         func=func,
                                         cache_manager=active_cache_manager,
@@ -284,20 +321,27 @@ def cache_with_deps(
                 finally:
                     current_deps = get_current_dependencies()
                     effective_ttl = get_cache_ttl()
-                    await _cache_result_or_exception_async(
-                        active_cache_manager,
-                        cache_key,
-                        result,
-                        exception,
-                        current_deps,
-                        effective_ttl,
-                        cache_exception_types,
+
+                    # Try to set cache with optional error silencing
+                    await _safe_backend_op_async(
+                        lambda: _cache_result_or_exception_async(
+                            active_cache_manager,
+                            cache_key,
+                            result,
+                            exception,
+                            current_deps,
+                            effective_ttl,
+                            cache_exception_types,
+                        ),
+                        silent_backend_errors,
+                        func.__qualname__,
+                        "cache set",
                     )
 
                     # Invoke callback for cache miss
                     if valid_callback:
                         try:
-                            if asyncio.iscoroutinefunction(valid_callback):
+                            if inspect.iscoroutinefunction(valid_callback):
                                 await valid_callback(
                                     func=func,
                                     cache_manager=active_cache_manager,
@@ -338,7 +382,14 @@ def cache_with_deps(
 
                 cache_key = _generate_cache_key(func, args, kwargs)
 
-                cached_result = active_cache_manager.get(cache_key)
+                # Try to get from cache with optional error silencing
+                cached_result = _safe_backend_op(
+                    lambda: active_cache_manager.get(cache_key),
+                    silent_backend_errors,
+                    func.__qualname__,
+                    "cache get",
+                )
+
                 if cached_result is not None:
                     cache_hit_result = _handle_cache_hit(cached_result)
                     if cache_hit_result is not None:
@@ -368,14 +419,21 @@ def cache_with_deps(
                 finally:
                     current_deps = get_current_dependencies()
                     effective_ttl = get_cache_ttl()
-                    _cache_result_or_exception_sync(
-                        active_cache_manager,
-                        cache_key,
-                        result,
-                        exception,
-                        current_deps,
-                        effective_ttl,
-                        cache_exception_types,
+
+                    # Try to set cache with optional error silencing
+                    _safe_backend_op(
+                        lambda: _cache_result_or_exception_sync(
+                            active_cache_manager,
+                            cache_key,
+                            result,
+                            exception,
+                            current_deps,
+                            effective_ttl,
+                            cache_exception_types,
+                        ),
+                        silent_backend_errors,
+                        func.__qualname__,
+                        "cache set",
                     )
 
                     # Invoke callback for cache miss

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/src/simple_dep_cache/events.py

@@ -1,8 +1,9 @@
 import logging
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from dataclasses import dataclass
 from enum import Enum
+from inspect import iscoroutinefunction
 from typing import Any
 
 from .config import ConfigBase
@@ -38,6 +39,9 @@ class CacheEvent:
             self.timestamp = time.time()
 
 
+CacheCallback = Callable[[CacheEvent], Any]
+
+
 class EventEmitter:
     """Simple event emitter for cache events."""
 
@@ -48,45 +52,67 @@ class EventEmitter:
         }
         self._global_callbacks: list[Callable] = []
 
-    def on(self, event_type: CacheEventType, callback: Callable[[CacheEvent], None]) -> None:
+    def on(self, event_type: CacheEventType, callback: CacheCallback) -> None:
         """Register a callback for a specific event type."""
         self._callbacks[event_type].append(callback)
 
-    def on_all(self, callback: Callable[[CacheEvent], None]) -> None:
+    def on_all(self, callback: CacheCallback) -> None:
         """Register a callback for all event types."""
         self._global_callbacks.append(callback)
 
-    def off(self, event_type: CacheEventType, callback: Callable[[CacheEvent], None]) -> bool:
+    def off(self, event_type: CacheEventType, callback: CacheCallback) -> bool:
         """Unregister a callback for a specific event type."""
         if callback in self._callbacks[event_type]:
             self._callbacks[event_type].remove(callback)
             return True
         return False
 
-    def off_all(self, callback: Callable[[CacheEvent], None]) -> bool:
+    def off_all(self, callback: CacheCallback) -> bool:
         """Unregister a callback from all events."""
         if callback in self._global_callbacks:
             self._global_callbacks.remove(callback)
             return True
         return False
 
+    def _iter_callbacks(self, event_type: CacheEventType) -> Iterator[Callable]:
+        """Yield specific-then-global callbacks for an event type."""
+        yield from self._callbacks[event_type]
+        yield from self._global_callbacks
+
+    def has_async_callbacks(self, event_type: CacheEventType) -> bool:
+        """True if any registered callback for this event type is a coroutine function."""
+        return any(iscoroutinefunction(cb) for cb in self._iter_callbacks(event_type))
+
+    def _handle_callback_error(self, error: Exception) -> None:
+        if not self.config.callback_error_silent:
+            logger.exception("Error in cache event callback: %s", error)
+
     def emit(self, event: CacheEvent) -> None:
-        """Emit an event to all registered callbacks."""
-        # Call specific event callbacks
-        for callback in self._callbacks[event.event_type]:
+        """Dispatch the event to all *sync* callbacks.
+
+        Async callbacks are skipped here; they are dispatched by :meth:`aemit`
+        from the manager's async methods.
+        """
+        for callback in self._iter_callbacks(event.event_type):
+            if iscoroutinefunction(callback):
+                continue
             try:
                 callback(event)
             except Exception as e:
-                if not self.config.callback_error_silent:
-                    logger.exception("Error in cache event callback: %s", e)
+                self._handle_callback_error(e)
+
+    async def aemit(self, event: CacheEvent) -> None:
+        """Dispatch the event to all *async* callbacks, awaiting each.
 
-        # Call global callbacks
-        for callback in self._global_callbacks:
+        Sync callbacks are skipped here; they are dispatched by :meth:`emit`.
+        """
+        for callback in self._iter_callbacks(event.event_type):
+            if not iscoroutinefunction(callback):
+                continue
             try:
-                callback(event)
+                await callback(event)
             except Exception as e:
-                if not self.config.callback_error_silent:
-                    logger.exception("Error in cache event callback: %s", e)
+                self._handle_callback_error(e)
 
     def clear_all(self) -> None:
         """Clear all callbacks."""
@@ -148,7 +174,7 @@ class StatsCollector:
         self.start_time = time.time()
 
 
-def create_logger_callback(name: str = "cache") -> Callable[[CacheEvent], None]:
+def create_logger_callback(name: str = "cache") -> CacheCallback:
     """Create a callback that logs cache events."""
 
     def logger_callback(event: CacheEvent) -> None:

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/src/simple_dep_cache/manager.py

@@ -2,12 +2,11 @@ import builtins
 import threading
 import time
 import warnings
-from collections.abc import Callable
 from typing import Optional
 
 from .backends import AsyncCacheBackend, CacheBackend
 from .config import ConfigBase, RedisConfig
-from .events import CacheEvent, CacheEventType, EventEmitter
+from .events import CacheCallback, CacheEvent, CacheEventType, EventEmitter
 from .types import CacheValue
 
 _manager_lock = threading.Lock()
@@ -115,6 +114,26 @@ class CacheManager:
         else:
             raise RuntimeError("No backend available.")
 
+    def _emit(self, event: CacheEvent) -> None:
+        """Dispatch an event from a synchronous operation.
+
+        Sync operations can't await, so an async callback registered for this
+        event has no way to run -- that's a misconfiguration, so we raise rather
+        than silently drop it. Use the async (a*) methods for async callbacks.
+        """
+        if self.events.has_async_callbacks(event.event_type):
+            raise RuntimeError(
+                f"An async callback is registered for {event.event_type}, but it was "
+                f"triggered by a synchronous cache operation and cannot be awaited. "
+                f"Use the async ('a'-prefixed) methods, or register a sync callback."
+            )
+        self.events.emit(event)
+
+    async def _aemit(self, event: CacheEvent) -> None:
+        """Dispatch an event from an asynchronous operation (sync + async callbacks)."""
+        self.events.emit(event)
+        await self.events.aemit(event)
+
     def set(
         self,
         key: str,
@@ -128,7 +147,7 @@ class CacheManager:
 
         self.backend.set(key, value, ttl, dependencies)
 
-        self.events.emit(
+        self._emit(
             CacheEvent(
                 event_type=CacheEventType.SET,
                 key=key,
@@ -160,7 +179,7 @@ class CacheManager:
         else:
             raise RuntimeError("No backend available. Provide either 'backend' or 'async_backend'.")
 
-        self.events.emit(
+        await self._aemit(
             CacheEvent(
                 event_type=CacheEventType.SET,
                 key=key,
@@ -179,12 +198,10 @@ class CacheManager:
         value = self.backend.get(key)
 
         if value is None:
-            self.events.emit(
-                CacheEvent(event_type=CacheEventType.MISS, key=key, timestamp=time.time())
-            )
+            self._emit(CacheEvent(event_type=CacheEventType.MISS, key=key, timestamp=time.time()))
             return None
 
-        self.events.emit(
+        self._emit(
             CacheEvent(
                 event_type=CacheEventType.HIT,
                 key=key,
@@ -210,12 +227,12 @@ class CacheManager:
             raise RuntimeError("No backend available. Provide either 'backend' or 'async_backend'.")
 
         if value is None:
-            self.events.emit(
+            await self._aemit(
                 CacheEvent(event_type=CacheEventType.MISS, key=key, timestamp=time.time())
             )
             return None
 
-        self.events.emit(
+        await self._aemit(
             CacheEvent(
                 event_type=CacheEventType.HIT,
                 key=key,
@@ -233,7 +250,7 @@ class CacheManager:
         count = self.backend.delete(*keys)
 
         for key in keys:
-            self.events.emit(
+            self._emit(
                 CacheEvent(
                     event_type=CacheEventType.DELETE,
                     key=key,
@@ -260,7 +277,7 @@ class CacheManager:
             raise RuntimeError("No backend available. Provide either 'backend' or 'async_backend'.")
 
         for key in keys:
-            self.events.emit(
+            await self._aemit(
                 CacheEvent(
                     event_type=CacheEventType.DELETE,
                     key=key,
@@ -278,7 +295,7 @@ class CacheManager:
 
         count = self.backend.clear(pattern)
 
-        self.events.emit(
+        self._emit(
             CacheEvent(
                 event_type=CacheEventType.CLEAR,
                 key=pattern,
@@ -304,7 +321,7 @@ class CacheManager:
         else:
             raise RuntimeError("No backend available. Provide either 'backend' or 'async_backend'.")
 
-        self.events.emit(
+        await self._aemit(
             CacheEvent(
                 event_type=CacheEventType.CLEAR,
                 key=pattern,
@@ -325,7 +342,7 @@ class CacheManager:
         count = self.backend.invalidate_dependency(dependency)
 
         # Emit invalidate event
-        self.events.emit(
+        self._emit(
             CacheEvent(
                 event_type=CacheEventType.INVALIDATE,
                 key=dependency,
@@ -352,7 +369,7 @@ class CacheManager:
         else:
             raise RuntimeError("No backend available. Provide either 'backend' or 'async_backend'.")
 
-        self.events.emit(
+        await self._aemit(
             CacheEvent(
                 event_type=CacheEventType.INVALIDATE,
                 key=dependency,
@@ -407,7 +424,7 @@ class CacheManager:
         else:
             raise RuntimeError("No backend available. Provide either 'backend' or 'async_backend'.")
 
-    def on_event(self, event_type: CacheEventType, callback: Callable[[CacheEvent], None]) -> None:
+    def on_event(self, event_type: CacheEventType, callback: CacheCallback) -> None:
         """Register a callback for a specific cache event type.
 
         Args:
@@ -416,7 +433,7 @@ class CacheManager:
         """
         self.events.on(event_type, callback)
 
-    def on_all_events(self, callback: Callable[[CacheEvent], None]) -> None:
+    def on_all_events(self, callback: CacheCallback) -> None:
         """Register a callback for all cache events.
 
         Args:
@@ -424,9 +441,7 @@ class CacheManager:
         """
         self.events.on_all(callback)
 
-    def remove_event_callback(
-        self, event_type: CacheEventType, callback: Callable[[CacheEvent], None]
-    ) -> bool:
+    def remove_event_callback(self, event_type: CacheEventType, callback: CacheCallback) -> bool:
         """Remove a callback for a specific event type.
 
         Args:
@@ -438,7 +453,7 @@ class CacheManager:
         """
         return self.events.off(event_type, callback)
 
-    def remove_all_events_callback(self, callback: Callable[[CacheEvent], None]) -> bool:
+    def remove_all_events_callback(self, callback: CacheCallback) -> bool:
         """Remove a callback from all events.
 
         Args:

{simple_dep_cache-0.2.0 → simple_dep_cache-0.3.0}/src/simple_dep_cache/types.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
+
 import json
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Protocol, Self, runtime_checkable
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
 from .config import ConfigBase
 from .utils import DynamicImporter
 
 if TYPE_CHECKING:
+    from typing import Self
+
     import orjson
 
 try:

simple_dep_cache-0.3.0/tests/test_async_callbacks.py

@@ -0,0 +1,111 @@
+"""Tests for async event-callback dispatch on the cache manager."""
+
+import pytest
+
+from simple_dep_cache.config import ConfigBase
+from simple_dep_cache.events import CacheEvent, CacheEventType
+from simple_dep_cache.fakes import FakeAsyncCacheBackend, FakeCacheBackend
+from simple_dep_cache.manager import CacheManager
+
+
+def _sync_manager():
+    config = ConfigBase(prefix="t")
+    return CacheManager(config, name="t", backend=FakeCacheBackend(config))
+
+
+def _async_manager():
+    config = ConfigBase(prefix="t")
+    return CacheManager(config, name="t", async_backend=FakeAsyncCacheBackend(config))
+
+
+class TestSyncDispatch:
+    def test_sync_callback_runs_on_sync_op(self):
+        seen = []
+        m = _sync_manager()
+        m.on_event(CacheEventType.INVALIDATE, lambda e: seen.append(e.key))
+        m.invalidate_dependency("dep:1")
+        assert seen == ["dep:1"]
+
+    def test_async_callback_on_sync_op_raises(self):
+        m = _sync_manager()
+
+        async def acb(event):  # noqa: RUF029
+            pass
+
+        m.on_event(CacheEventType.INVALIDATE, acb)
+        with pytest.raises(RuntimeError, match="async callback"):
+            m.invalidate_dependency("dep:1")
+
+    def test_emit_skips_async_callbacks(self):
+        # EventEmitter.emit itself must never try to call an async callback.
+        sync_seen, async_seen = [], []
+        m = _sync_manager()
+
+        async def acb(event):
+            async_seen.append(event.key)
+
+        m.on_event(CacheEventType.SET, lambda e: sync_seen.append(e.key))
+        m.on_event(CacheEventType.SET, acb)
+        # direct emit -> only sync callback runs, no coroutine leaked
+        m.events.emit(CacheEvent(event_type=CacheEventType.SET, key="k", timestamp=0.0))
+        assert sync_seen == ["k"]
+        assert async_seen == []
+
+
+class TestAsyncDispatch:
+    @pytest.mark.asyncio
+    async def test_async_callback_runs_on_async_op(self):
+        seen = []
+        m = _async_manager()
+
+        async def acb(event):
+            seen.append(event.key)
+
+        m.on_event(CacheEventType.INVALIDATE, acb)
+        await m.ainvalidate_dependency("dep:1")
+        assert seen == ["dep:1"]
+
+    @pytest.mark.asyncio
+    async def test_sync_callback_also_runs_on_async_op(self):
+        seen = []
+        m = _async_manager()
+        m.on_event(CacheEventType.INVALIDATE, lambda e: seen.append(e.key))
+        await m.ainvalidate_dependency("dep:1")
+        assert seen == ["dep:1"]
+
+    @pytest.mark.asyncio
+    async def test_both_sync_and_async_run_on_async_op(self):
+        sync_seen, async_seen = [], []
+        m = _async_manager()
+
+        async def acb(event):
+            async_seen.append(event.key)
+
+        m.on_event(CacheEventType.INVALIDATE, lambda e: sync_seen.append(e.key))
+        m.on_event(CacheEventType.INVALIDATE, acb)
+        await m.ainvalidate_dependency("dep:1")
+        assert sync_seen == ["dep:1"]
+        assert async_seen == ["dep:1"]
+
+
+class TestHasAsyncCallbacks:
+    def test_detection(self):
+        m = _sync_manager()
+        assert m.events.has_async_callbacks(CacheEventType.SET) is False
+        m.on_event(CacheEventType.SET, lambda e: None)
+        assert m.events.has_async_callbacks(CacheEventType.SET) is False
+
+        async def acb(event):
+            pass
+
+        m.on_event(CacheEventType.SET, acb)
+        assert m.events.has_async_callbacks(CacheEventType.SET) is True
+
+    def test_global_async_callback_detected(self):
+        m = _sync_manager()
+
+        async def acb(event):
+            pass
+
+        m.on_all_events(acb)
+        assert m.events.has_async_callbacks(CacheEventType.HIT) is True

simple_dep_cache-0.3.0/tests/test_silent_backend_errors.py

@@ -0,0 +1,207 @@
+"""Tests for the silent_backend_errors parameter in cache_with_deps decorator."""
+
+from unittest.mock import Mock
+
+import pytest
+
+from simple_dep_cache.decorators import cache_with_deps
+from simple_dep_cache.fakes import FakeAsyncCacheBackend, FakeCacheBackend, FakeConfig
+from simple_dep_cache.manager import get_or_create_cache_manager
+
+
+class TestSilentBackendErrors:
+    """Test cases for silent_backend_errors parameter."""
+
+    def test_silent_backend_errors_on_get(self):
+        """Test that backend errors during get are silently logged."""
+        # Create a fake backend that will raise an error on get
+        config = FakeConfig(prefix="test_get_error")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_get_error", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Should execute function normally despite backend error
+        result = my_function(5)
+        assert result == 10
+        assert call_count == 1
+
+    def test_silent_backend_errors_on_set(self):
+        """Test that backend errors during set are silently logged."""
+        # Create a fake backend that will raise an error on set
+        config = FakeConfig(prefix="test_set_error")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_set_error", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's set method to raise an error
+        backend.set = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Should execute function normally despite backend error
+        result = my_function(5)
+        assert result == 10
+        assert call_count == 1
+
+    def test_silent_backend_errors_disabled_by_default(self):
+        """Test that backend errors are raised by default (silent_backend_errors=False)."""
+        # Create a fake backend that will raise an error on get
+        config = FakeConfig(prefix="test_error_default")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_error_default", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        @cache_with_deps(name=cache_manager.name)
+        def my_function(x):
+            return x * 2
+
+        # Should raise the backend error
+        with pytest.raises(ConnectionError, match="Redis connection failed"):
+            my_function(5)
+
+    @pytest.mark.asyncio
+    async def test_silent_backend_errors_with_async(self):
+        """Test that silent_backend_errors works with async functions."""
+        # Create a fake async backend that will raise an error on get
+        config = FakeConfig(prefix="test_async_error")
+        async_backend = FakeAsyncCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_async_error",
+            config=config,
+            async_backend=async_backend,
+            create_async_backend=True,
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        async def mock_get(key):
+            raise ConnectionError("Redis connection failed")
+
+        async_backend.get = mock_get
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        async def my_async_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Should execute function normally despite backend error
+        result = await my_async_function(5)
+        assert result == 10
+        assert call_count == 1
+
+    @pytest.mark.asyncio
+    async def test_silent_backend_errors_async_disabled_by_default(self):
+        """Test that backend errors are raised by default in async functions."""
+        # Create a fake async backend that will raise an error on get
+        config = FakeConfig(prefix="test_async_error_default")
+        async_backend = FakeAsyncCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_async_error_default",
+            config=config,
+            async_backend=async_backend,
+            create_async_backend=True,
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get method to raise an error
+        async def mock_get(key):
+            raise ConnectionError("Redis connection failed")
+
+        async_backend.get = mock_get
+
+        @cache_with_deps(name=cache_manager.name)
+        async def my_async_function(x):
+            return x * 2
+
+        # Should raise the backend error
+        with pytest.raises(ConnectionError, match="Redis connection failed"):
+            await my_async_function(5)
+
+    def test_silent_backend_errors_multiple_calls(self):
+        """Test that function executes correctly with persistent backend errors."""
+        config = FakeConfig(prefix="test_multiple_calls")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_multiple_calls", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend to always fail
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+        backend.set = Mock(side_effect=ConnectionError("Redis connection failed"))
+
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # Call multiple times - should work each time
+        result1 = my_function(5)
+        result2 = my_function(10)
+        result3 = my_function(5)  # Same arg as first call
+
+        assert result1 == 10
+        assert result2 == 20
+        assert result3 == 10
+        assert call_count == 3  # Function called every time (no caching due to backend errors)
+
+    def test_silent_backend_errors_partial_failure(self):
+        """Test behavior when only get fails but set works."""
+        config = FakeConfig(prefix="test_partial_failure")
+        backend = FakeCacheBackend(config)
+        cache_manager = get_or_create_cache_manager(
+            name="test_partial_failure", config=config, backend=backend
+        )
+        assert cache_manager is not None
+
+        # Mock the backend's get to fail, but set works normally
+        backend.get = Mock(side_effect=ConnectionError("Redis connection failed"))
+        call_count = 0
+
+        @cache_with_deps(name=cache_manager.name, silent_backend_errors=True)
+        def my_function(x):
+            nonlocal call_count
+            call_count += 1
+            return x * 2
+
+        # First call: get fails, function executes, set succeeds
+        result1 = my_function(5)
+        assert result1 == 10
+        assert call_count == 1
+
+        # Second call: get still fails, function executes again
+        result2 = my_function(5)
+        assert result2 == 10
+        assert call_count == 2  # Function called again due to get failure