refactor: update type hints for regex and JSON/YAML test functions

Author: iamtatsuki05

src/project/common/regex.py

@@ -4,7 +4,7 @@
 from project.common.utils.regex_utils import concat, unmatched_group
 
 # time regex
-TIME_PATTRN: Final[re.Pattern] = re.compile(r'\d+:\d+')
+TIME_PATTRN: Final[re.Pattern[str]] = re.compile(r'\d+:\d+')
 
 
 # email regex

tests/project/common/utils/file/test_json.py

@@ -4,7 +4,7 @@
 
 import pytest
 
-from project.common.utils.file.json import load_json, save_as_indented_json
+from project.common.utils.file.json import JsonValue, load_json, save_as_indented_json
 
 
 @pytest.mark.parametrize(
@@ -17,7 +17,7 @@
         ('[]', []),
     ],
 )
-def test_load_json(input_data: str, expected_result: object) -> None:
+def test_load_json(input_data: str, expected_result: JsonValue) -> None:
     """Test that load_json correctly loads and parses JSON data."""
     # Mock the open function to return our test data
     with patch('pathlib.Path.open', mock_open(read_data=input_data)):
@@ -40,7 +40,7 @@ def test_load_json(input_data: str, expected_result: object) -> None:
         ([],),
     ],
 )
-def test_save_as_indented_json(input_data_tuple: tuple[object, ...]) -> None:
+def test_save_as_indented_json(input_data_tuple: tuple[JsonValue, ...]) -> None:
     """Test that save_as_indented_json correctly writes JSON data to a file."""
     input_data = input_data_tuple[0]
     mock_file = mock_open()

tests/project/common/utils/file/test_yaml.py

@@ -3,7 +3,7 @@
 
 import pytest
 
-from project.common.utils.file.yaml import load_yaml, save_as_indented_yaml
+from project.common.utils.file.yaml import YamlValue, load_yaml, save_as_indented_yaml
 
 
 @pytest.mark.parametrize(
@@ -16,7 +16,7 @@
         ('[]', []),
     ],
 )
-def test_load_yaml(input_data: str, expected_result: object) -> None:
+def test_load_yaml(input_data: str, expected_result: YamlValue) -> None:
     """Test that load_yaml correctly loads and parses YAML data."""
     # Mock the open function to return our test data
     with patch('pathlib.Path.open', mock_open(read_data=input_data)):
@@ -39,7 +39,7 @@ def test_load_yaml(input_data: str, expected_result: object) -> None:
         ([],),
     ],
 )
-def test_save_as_indented_yaml(input_data_tuple: tuple[object, ...]) -> None:
+def test_save_as_indented_yaml(input_data_tuple: tuple[YamlValue, ...]) -> None:
     """Test that save_as_indented_yaml correctly writes YAML data to a file."""
     input_data = input_data_tuple[0]
     mock_file = mock_open()

tests/project/common/utils/test_async_utils.py

@@ -1,4 +1,5 @@
 import asyncio
+import inspect
 from unittest.mock import AsyncMock
 
 import pytest
@@ -87,11 +88,11 @@ async def test_run_async_function_with_semaphore(use_semaphore_tuple: tuple[bool
     """Test that run_async_function_with_semaphore correctly manages the semaphore."""
     use_semaphore = use_semaphore_tuple[0]
     mock_async_func = AsyncMock(return_value='result')
-    mock_semaphore = AsyncMock() if use_semaphore else None
+    mock_semaphore: AsyncMock | None = AsyncMock() if use_semaphore else None
 
     # If a semaphore is provided, it should be used via async with
     if use_semaphore:
-        assert mock_semaphore is not None  # Type narrowing for mypy
+        assert mock_semaphore is not None
         mock_semaphore.__aenter__ = AsyncMock()
         mock_semaphore.__aexit__ = AsyncMock()
 
@@ -102,7 +103,7 @@ async def test_run_async_function_with_semaphore(use_semaphore_tuple: tuple[bool
 
     # If a semaphore was provided, verify it was acquired and released
     if use_semaphore:
-        assert mock_semaphore is not None  # Type narrowing for mypy
+        assert mock_semaphore is not None
         mock_semaphore.__aenter__.assert_called_once()
         mock_semaphore.__aexit__.assert_called_once()
 
@@ -131,30 +132,20 @@ async def call(self, *args: object, **kwargs: object) -> str:
     async def test_semaphore_limits_concurrency(self, concurrency: int, num_tasks: int) -> None:
         """Test that AsyncResource correctly limits concurrency using its semaphore."""
         resource = self.TestResource(concurrency=concurrency)
-        resource.call_mock.return_value = 'test_result'
-
-        # Track the number of concurrent executions
         max_concurrent = 0
         current_concurrent = 0
-        original_aenter = resource.semaphore.__aenter__
 
-        async def tracking_aenter(self: asyncio.Semaphore) -> asyncio.Semaphore:
+        async def tracked_call(*_args: object, **_kwargs: object) -> str:
             nonlocal current_concurrent, max_concurrent
-            await original_aenter()
             current_concurrent += 1
             max_concurrent = max(max_concurrent, current_concurrent)
-            return self
-
-        original_aexit = resource.semaphore.__aexit__
-
-        async def tracking_aexit(_self: asyncio.Semaphore, *args: object) -> object:
-            nonlocal current_concurrent
-            current_concurrent -= 1
-            return await original_aexit(*args)
+            try:
+                await asyncio.sleep(0.01)
+                return 'test_result'
+            finally:
+                current_concurrent -= 1
 
-        # Replace the enter and exit methods to track concurrency
-        resource.semaphore.__aenter__ = tracking_aenter.__get__(resource.semaphore)
-        resource.semaphore.__aexit__ = tracking_aexit.__get__(resource.semaphore)
+        resource.call_mock.side_effect = tracked_call
 
         # Create and gather multiple tasks
         tasks = [resource.task(f'arg{i}') for i in range(num_tasks)]
@@ -174,6 +165,4 @@ async def tracking_aexit(_self: asyncio.Semaphore, *args: object) -> object:
     @pytest.mark.asyncio
     async def test_abstract_call_method(self) -> None:
         """Test that AsyncResource.call is abstract and must be implemented."""
-        # We can't instantiate AsyncResource directly because it's abstract
-        with pytest.raises(TypeError, match=r'abstract method'):
-            AsyncResource()
+        assert inspect.isabstract(AsyncResource)