@@ -1,8 +1,9 @@
+# Always import asyncio
+import asyncio
 from collections.abc import Awaitable, Callable, Generator
 from functools import wraps
 from typing import Literal, NewType, ParamSpec, Protocol, TypeVar, cast, final
-# Always import asyncio
-import asyncio
+
 
 class AsyncLock(Protocol):
     """A protocol for an asynchronous lock."""
@@ -15,7 +16,7 @@ async def __aexit__(self, exc_type, exc_val, exc_tb) -> None: ...
 
 
 # Define context types as literals
-AsyncContext = Literal["asyncio", "trio", "unknown"]
+AsyncContext = Literal['asyncio', 'trio', 'unknown']
 
 
 def _is_anyio_available() -> bool:
@@ -60,10 +61,10 @@ def _is_in_trio_context() -> bool:
     """
     if not has_trio:
         return False  # pragma: no cover
-        
+
     # Import trio here since we already checked it's available
     import trio
-    
+
     try:
         # Will raise RuntimeError if not in trio context
         trio.lowlevel.current_task()
@@ -80,13 +81,13 @@ def detect_async_context() -> AsyncContext:
         AsyncContext: The current async context type
     """
     if not has_anyio:  # pragma: no cover
-        return "asyncio"
+        return 'asyncio'
 
     if _is_in_trio_context():
-        return "trio"
+        return 'trio'
 
     # Default to asyncio
-    return "asyncio"
+    return 'asyncio'
 
 
 _ValueType = TypeVar('_ValueType')
@@ -145,7 +146,9 @@ def __init__(self, coro: Awaitable[_ValueType]) -> None:
         """We need just an awaitable to work with."""
         self._coro = coro
         self._cache: _ValueType | _Sentinel = _sentinel
-        self._lock: AsyncLock | None = None  # Will be created lazily based on the backend
+        self._lock: AsyncLock | None = (
+            None  # Will be created lazily based on the backend
+        )
 
     def __await__(self) -> Generator[None, None, _ValueType]:
         """
@@ -195,14 +198,14 @@ def _create_lock(self) -> AsyncLock:
         """Create the appropriate lock based on the current async context."""
         context = detect_async_context()
 
-        if context == "trio" and has_anyio:
+        if context == 'trio' and has_anyio:
             try:
                 import anyio
             except Exception:  # pragma: no cover
                 # Just continue to asyncio if anyio import fails
                 return asyncio.Lock()  # pragma: no cover
             return anyio.Lock()  # pragma: no cover
-                
+
         # For asyncio or unknown contexts
         return asyncio.Lock()
 
@@ -222,6 +225,8 @@ async def _awaitable(self) -> _ValueType:
             if self._cache is _sentinel:
                 self._cache = await self._coro
             return self._cache  # type: ignore
+
+
 # pragma: no cover
 
 
@@ -258,4 +263,4 @@ def decorator(
     ) -> _AwaitableT:
         return ReAwaitable(coro(*args, **kwargs))  # type: ignore[return-value]
 
-    return decorator
+    return decorator