Address Copilot review feedback

- Use Path.suffix.lower() for case-insensitive .json detection in _save_response so Path('x.JSON') is treated as full-path mode.
- Expand _save_response docstring to describe both modes and the 'output' filename special case.
- Wrap AsyncLandingAIADE in async-with in test_save_to.py to close the underlying httpx client and avoid resource warnings.

Author: mikesoennichsen

src/landingai_ade/_client.py

@@ -128,14 +128,16 @@ def _save_response(
 ) -> None:
     """Save API response to a JSON file.
 
-    If save_to ends with '.json', it is treated as a full file path and the
-    response is written there directly. Otherwise it is treated as a directory
-    and the file is auto-named '{filename}_{method_name}_output.json'
-    (or '{method_name}_output.json' when filename is 'output').
+    If save_to has a '.json' suffix (case-insensitive), it is treated as a full
+    file path and the response is written there directly. Otherwise it is
+    treated as a directory and the file is auto-named
+    '{filename}_{method_name}_output.json', except when filename is 'output'
+    (i.e. no input filename could be derived) — in that case the redundant
+    prefix is dropped and the file is named '{method_name}_output.json'.
     """
     try:
         save_path = Path(save_to)
-        if str(save_to).endswith(".json"):
+        if save_path.suffix.lower() == ".json":
             save_path.parent.mkdir(parents=True, exist_ok=True)
             save_path.write_text(result.to_json())
         else:

tests/test_save_to.py

@@ -220,13 +220,13 @@ def mock_response(self) -> MagicMock:
     async def test_async_extract_save_to_directory(self, tmp_path: Path, mock_response: MagicMock) -> None:
         from unittest.mock import AsyncMock, patch
 
-        client = AsyncLandingAIADE(apikey="test-key", base_url="http://localhost")
-        with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
-            result = await client.extract(
-                schema="{}",
-                markdown=Path("/path/to/doc.pdf"),
-                save_to=tmp_path,
-            )
+        async with AsyncLandingAIADE(apikey="test-key", base_url="http://localhost") as client:
+            with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
+                result = await client.extract(
+                    schema="{}",
+                    markdown=Path("/path/to/doc.pdf"),
+                    save_to=tmp_path,
+                )
 
         assert (tmp_path / "doc_extract_output.json").exists()
         assert result is mock_response
@@ -236,43 +236,43 @@ async def test_async_extract_save_to_json_path(self, tmp_path: Path, mock_respon
         from unittest.mock import AsyncMock, patch
 
         output_file = tmp_path / "custom.json"
-        client = AsyncLandingAIADE(apikey="test-key", base_url="http://localhost")
-        with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
-            await client.extract(schema="{}", markdown=Path("/doc.pdf"), save_to=output_file)
+        async with AsyncLandingAIADE(apikey="test-key", base_url="http://localhost") as client:
+            with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
+                await client.extract(schema="{}", markdown=Path("/doc.pdf"), save_to=output_file)
 
         assert output_file.exists()
 
     @pytest.mark.asyncio
     async def test_async_parse_save_to(self, tmp_path: Path, mock_response: MagicMock) -> None:
         from unittest.mock import AsyncMock, patch
 
-        client = AsyncLandingAIADE(apikey="test-key", base_url="http://localhost")
-        with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
-            await client.parse(document=Path("/path/to/doc.pdf"), save_to=tmp_path)
+        async with AsyncLandingAIADE(apikey="test-key", base_url="http://localhost") as client:
+            with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
+                await client.parse(document=Path("/path/to/doc.pdf"), save_to=tmp_path)
 
         assert (tmp_path / "doc_parse_output.json").exists()
 
     @pytest.mark.asyncio
     async def test_async_split_save_to(self, tmp_path: Path, mock_response: MagicMock) -> None:
         from unittest.mock import AsyncMock, patch
 
-        client = AsyncLandingAIADE(apikey="test-key", base_url="http://localhost")
-        with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
-            await client.split(
-                split_class=[{"name": "type1"}],
-                markdown=Path("/path/to/doc.md"),
-                save_to=tmp_path,
-            )
+        async with AsyncLandingAIADE(apikey="test-key", base_url="http://localhost") as client:
+            with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
+                await client.split(
+                    split_class=[{"name": "type1"}],
+                    markdown=Path("/path/to/doc.md"),
+                    save_to=tmp_path,
+                )
 
         assert (tmp_path / "doc_split_output.json").exists()
 
     @pytest.mark.asyncio
     async def test_async_no_save_when_save_to_none(self, tmp_path: Path, mock_response: MagicMock) -> None:
         from unittest.mock import AsyncMock, patch
 
-        client = AsyncLandingAIADE(apikey="test-key", base_url="http://localhost")
-        with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
-            result = await client.extract(schema="{}")
+        async with AsyncLandingAIADE(apikey="test-key", base_url="http://localhost") as client:
+            with patch.object(client, "post", new_callable=AsyncMock, return_value=mock_response):
+                result = await client.extract(schema="{}")
 
         assert result is mock_response
         assert not list(tmp_path.iterdir())