Fix flake8 issues in reawaitable.py by using Literal instead of Enum

Author: proboscis

returns/primitives/reawaitable.py

@@ -1,7 +1,8 @@
 from collections.abc import Awaitable, Callable, Generator
 from functools import wraps
-from typing import NewType, ParamSpec, Protocol, TypeVar, cast, final
-
+from typing import Literal, NewType, ParamSpec, Protocol, TypeVar, cast, final
+# Always import asyncio
+import asyncio
 
 class AsyncLock(Protocol):
     """A protocol for an asynchronous lock."""
@@ -13,26 +14,17 @@ async def __aenter__(self) -> None: ...
     async def __aexit__(self, exc_type, exc_val, exc_tb) -> None: ...
 
 
-# Import both libraries if available
-import asyncio  # noqa: WPS433
-from enum import Enum, auto
-
-
-class AsyncContext(Enum):
-    """Enum representing different async context types."""
-
-    ASYNCIO = auto()
-    TRIO = auto()
-    UNKNOWN = auto()
+# Define context types as literals
+AsyncContext = Literal["asyncio", "trio", "unknown"]
 
 
 # Check for anyio and trio availability
 try:
-    import anyio  # noqa: WPS433
+    import anyio  # pragma: no qa
 
     has_anyio = True
     try:
-        import trio  # noqa: WPS433
+        import trio  # pragma: no qa
 
         has_trio = True
     except ImportError:  # pragma: no cover
@@ -42,27 +34,40 @@ class AsyncContext(Enum):
     has_trio = False
 
 
+def _is_in_trio_context() -> bool:
+    """Check if we're in a trio context.
+
+    Returns:
+        bool: True if we're in a trio context
+    """
+    if not has_trio:
+        return False
+        
+    # 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()
+    except (RuntimeError, AttributeError):
+        return False
+    return True
+
+
 def detect_async_context() -> AsyncContext:
     """Detect which async context we're currently running in.
 
     Returns:
         AsyncContext: The current async context type
     """
     if not has_anyio:  # pragma: no cover
-        return AsyncContext.ASYNCIO
-
-    if has_trio:
-        try:
-            # Check if we're in a trio context
-            # Will raise RuntimeError if not in trio context
-            trio.lowlevel.current_task()
-            return AsyncContext.TRIO
-        except (RuntimeError, AttributeError):
-            # Not in a trio context or trio API changed
-            pass
+        return "asyncio"
+
+    if _is_in_trio_context():
+        return "trio"
 
     # Default to asyncio
-    return AsyncContext.ASYNCIO
+    return "asyncio"
 
 
 _ValueType = TypeVar('_ValueType')
@@ -121,7 +126,7 @@ 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 = 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]:
         """
@@ -171,10 +176,11 @@ def _create_lock(self) -> AsyncLock:
         """Create the appropriate lock based on the current async context."""
         context = detect_async_context()
 
-        if context == AsyncContext.TRIO and has_anyio:
+        if context == "trio" and has_anyio:
+            import anyio
             return anyio.Lock()
 
-        # For ASYNCIO or UNKNOWN contexts
+        # For asyncio or unknown contexts
         return asyncio.Lock()
 
     async def _awaitable(self) -> _ValueType:
@@ -222,4 +228,4 @@ def decorator(
     ) -> _AwaitableT:
         return ReAwaitable(coro(*args, **kwargs))  # type: ignore[return-value]
 
-    return decorator
+    return decorator