[pre-commit.ci] auto fixes from pre-commit.com hooks

Author: pre-commit-ci[bot]

.coveragerc

@@ -1,5 +1,5 @@
 [run]
-omit = 
+omit =
     returns/contrib/mypy/*
     returns/contrib/pytest/*.py
     returns/contrib/hypothesis/*
@@ -23,4 +23,4 @@ exclude_lines =
     def __init__
     def __aenter__
     def __aexit__
-    ->exit
+    ->exit

returns/primitives/reawaitable.py

@@ -1,19 +1,21 @@
+# 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
+
 
 # pragma: no cover
 class AsyncLock(Protocol):
     """A protocol for an asynchronous lock."""
+
     def __init__(self) -> None: ...
     async def __aenter__(self) -> None: ...
     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']
 
 
 # Functions for detecting async context - these are excluded from coverage
@@ -61,10 +63,10 @@ def _is_in_trio_context() -> bool:
     # Early return if trio is not available
     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()
@@ -82,9 +84,9 @@ def detect_async_context() -> AsyncContext:  # pragma: no cover
     """
     # This branch is only taken when anyio is not installed
     if not has_anyio or not _is_in_trio_context():
-        return "asyncio"
+        return 'asyncio'
 
-    return "trio"
+    return 'trio'
 
 
 _ValueType = TypeVar('_ValueType')
@@ -143,7 +145,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]:
         """
@@ -193,14 +197,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:
                 # Just continue to asyncio if anyio import fails
                 return asyncio.Lock()
             return anyio.Lock()
-                
+
         # For asyncio or unknown contexts
         return asyncio.Lock()
 
@@ -256,4 +260,4 @@ def decorator(
     ) -> _AwaitableT:
         return ReAwaitable(coro(*args, **kwargs))  # type: ignore[return-value]
 
-    return decorator
+    return decorator

tests/test_primitives/test_reawaitable/test_reawaitable_full_coverage.py

@@ -1,28 +1,28 @@
 import pytest
-from unittest.mock import patch, MagicMock
 
 from returns.primitives.reawaitable import (
-    ReAwaitable, 
+    ReAwaitable,
     reawaitable,
 )
 
 
 @pytest.mark.anyio
 async def test_reawaitable_lock_creation():
     """Test the _create_lock method for different contexts."""
+
     async def sample_coro() -> str:
         return 'value'
-    
+
     # Create a ReAwaitable instance
     instance = ReAwaitable(sample_coro())
-    
+
     # Test the lock is initially None
     assert instance._lock is None
-    
+
     # Await to trigger lock creation
     result = await instance
     assert result == 'value'
-    
+
     # Verify lock is created
     assert instance._lock is not None
 
@@ -34,17 +34,18 @@ async def sample_coro() -> str:
 @pytest.mark.anyio
 async def test_reawaitable_decorator():
     """Test the reawaitable decorator."""
+
     # Define a test coroutine
     @reawaitable
     async def test_func(value: int) -> int:
         return value * 2
-    
+
     # Call the decorated function
     result = test_func(5)
-    
+
     # Verify it can be awaited multiple times
     assert await result == 10
     assert await result == 10  # Should use cached value
 
 
-# Tests removed as we're using pragmas now
+# Tests removed as we're using pragmas now

tests/test_primitives/test_reawaitable/test_reawaitable_lock.py

@@ -1,32 +1,32 @@
 import pytest
-import anyio
 
 from returns.primitives.reawaitable import (
     ReAwaitable,
-    detect_async_context,
     _is_in_trio_context,
+    detect_async_context,
 )
 
 
 @pytest.mark.anyio
 async def test_reawaitable_create_lock():
     """Test that ReAwaitable correctly creates the lock when needed."""
+
     async def sample_coroutine() -> str:
         return 'test'
-    
+
     # Create ReAwaitable instance
     reawait = ReAwaitable(sample_coroutine())
-    
+
     # The lock should be None initially
     assert reawait._lock is None
-    
+
     # Await the coroutine once
     result1 = await reawait
-    
+
     # The lock should be created
     assert reawait._lock is not None
     assert result1 == 'test'
-    
+
     # Await again, should use the same lock
     result2 = await reawait
     assert result2 == 'test'
@@ -47,4 +47,4 @@ async def test_is_in_trio_context():
     # we just check the function runs without errors
     result = _is_in_trio_context()
     # Result will depend on which backend anyio is using
-    assert isinstance(result, bool)
+    assert isinstance(result, bool)