Live split/merge/summarize/translate: add async variants, missing option tests

Assisted-by: Codex

Author: datalogics-cgreen

tests/live/test_live_pdf_split_merge.py

@@ -151,6 +151,65 @@ def test_live_split_pdf_page_groups(
         assert str(response.input_id) == str(split_source.id)
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("page_groups", "expected_count"),
+    [
+        pytest.param(["1-5", "6-last"], 2, id="two-ranges"),
+        pytest.param([["1", "3", "5"], "2-4"], 2, id="alternating-selection"),
+        pytest.param(["even"], 1, id="even-only"),
+        pytest.param(["9-2"], 1, id="descending-single"),
+        pytest.param(["odd", "even"], 2, id="odd-and-even"),
+    ],
+)
+async def test_live_async_split_pdf_page_groups(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_live_pdfs: tuple[PdfRestFile, PdfRestFile],
+    page_groups: list[PdfPageSelection],
+    expected_count: int,
+) -> None:
+    split_source, _ = uploaded_live_pdfs
+
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        total_pages = await _fetch_page_count_async(client, split_source)
+
+        response = await client.split_pdf(
+            split_source,
+            page_groups=page_groups,
+            output_prefix="live-async-split",
+        )
+
+        assert len(response.output_files) == expected_count
+
+        output_infos = [
+            await client.query_pdf_info(output_file)
+            for output_file in response.output_files
+        ]
+
+        assert all(
+            output_file.name.startswith("live-async-split")
+            and output_file.name.endswith(".pdf")
+            and output_file.type == "application/pdf"
+            and output_file.size > 0
+            for output_file in response.output_files
+        )
+        page_counts_optional = [info.page_count for info in output_infos]
+        assert all(count is not None for count in page_counts_optional)
+        expected_page_counts = [
+            len(_expand_page_selection(group, total_pages=total_pages))
+            for group in page_groups
+        ][: len(page_counts_optional)]
+        page_counts = [
+            int(count) for count in page_counts_optional if count is not None
+        ]
+        assert page_counts == expected_page_counts
+        assert str(response.input_id) == str(split_source.id)
+
+
 def test_live_split_pdf_default_outputs(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
@@ -186,6 +245,43 @@ def test_live_split_pdf_default_outputs(
         assert str(response.input_id) == str(split_source.id)
 
 
+@pytest.mark.asyncio
+async def test_live_async_split_pdf_default_outputs(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_live_pdfs: tuple[PdfRestFile, PdfRestFile],
+) -> None:
+    split_source, _ = uploaded_live_pdfs
+
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        total_pages = await _fetch_page_count_async(client, split_source)
+
+        response = await client.split_pdf(
+            split_source,
+            output_prefix="live-async-split-default",
+        )
+
+        assert len(response.output_files) == total_pages
+
+        output_infos = [
+            await client.query_pdf_info(output_file)
+            for output_file in response.output_files
+        ]
+        assert all(
+            output_file.name.startswith("live-async-split-default")
+            and output_file.name.endswith(".pdf")
+            and output_file.type == "application/pdf"
+            and output_file.size > 0
+            for output_file in response.output_files
+        )
+        assert all(info.page_count == 1 for info in output_infos)
+
+        assert str(response.input_id) == str(split_source.id)
+
+
 def test_live_split_pdf_invalid_pages(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
@@ -207,6 +303,26 @@ def test_live_split_pdf_invalid_pages(
         )
 
 
+@pytest.mark.asyncio
+async def test_live_async_split_pdf_invalid_pages(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_live_pdfs: tuple[PdfRestFile, PdfRestFile],
+) -> None:
+    split_source, _ = uploaded_live_pdfs
+
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        with pytest.raises(PdfRestApiError, match=r"(?i)page"):
+            await client.split_pdf(
+                split_source,
+                page_groups=["1-2"],
+                extra_body={"pages": ["0"]},
+            )
+
+
 def test_live_merge_pdfs_success(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
@@ -254,6 +370,30 @@ def test_live_merge_pdfs_success(
         assert output_info.page_count == expected_total_pages
 
 
+@pytest.mark.asyncio
+async def test_live_async_merge_pdfs_invalid_pages(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_live_pdfs: tuple[PdfRestFile, PdfRestFile],
+) -> None:
+    split_source, merge_partner = uploaded_live_pdfs
+    sources: list[PdfMergeInput] = [
+        {"file": split_source, "pages": "even"},
+        {"file": merge_partner, "pages": "1"},
+    ]
+
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        with pytest.raises(PdfRestApiError, match=r"(?i)page"):
+            await client.merge_pdfs(
+                sources,
+                output_prefix="live-async-merge-invalid",
+                extra_body={"pages": ["even", "0"]},
+            )
+
+
 def test_live_merge_pdfs_invalid_pages(
     pdfrest_api_key: str,
     pdfrest_live_base_url: str,
@@ -382,6 +522,52 @@ def test_live_split_pdf_page_range_variants(
                 )
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("selection", "expect_success", "requires_override"), SPLIT_RANGE_CASES
+)
+async def test_live_async_split_pdf_page_range_variants(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_live_pdfs: tuple[PdfRestFile, PdfRestFile],
+    selection: PdfPageSelection,
+    expect_success: bool,
+    requires_override: bool,
+    request: pytest.FixtureRequest,
+) -> None:
+    split_source, _ = uploaded_live_pdfs
+    case_id = request.node.callspec.id
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        total_pages = await _fetch_page_count_async(client, split_source)
+        override_body = None
+        if requires_override:
+            override_body = {"pages": [str(selection)]}
+
+        if expect_success:
+            response = await client.split_pdf(
+                split_source,
+                page_groups=[selection if not requires_override else "1"],
+                output_prefix=f"live-async-split-range-{case_id}",
+                extra_body=override_body,
+            )
+            expected_pages = _expand_page_selection(selection, total_pages=total_pages)
+            output_pages = (
+                await client.query_pdf_info(response.output_files[0])
+            ).page_count
+            assert output_pages == len(expected_pages)
+        else:
+            with pytest.raises(PdfRestApiError, match=r"(?i)page"):
+                await client.split_pdf(
+                    split_source,
+                    page_groups=[selection if not requires_override else "1"],
+                    output_prefix=f"live-async-split-range-{case_id}",
+                    extra_body=override_body,
+                )
+
+
 MERGE_RANGE_CASES = [
     pytest.param("3", True, False, id="single-str"),
     pytest.param(3, True, False, id="single-int"),
@@ -452,3 +638,63 @@ def test_live_merge_pdf_page_range_variants(
                     output_prefix=f"live-merge-range-{case_id}",
                     extra_body=override_body,
                 )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("selection", "expect_success", "requires_override"), MERGE_RANGE_CASES
+)
+async def test_live_async_merge_pdf_page_range_variants(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_live_pdfs: tuple[PdfRestFile, PdfRestFile],
+    selection: PdfPageSelection,
+    expect_success: bool,
+    requires_override: bool,
+    request: pytest.FixtureRequest,
+) -> None:
+    split_source, merge_partner = uploaded_live_pdfs
+    case_id = request.node.callspec.id
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        source_page_counts = {
+            str(split_source.id): await _fetch_page_count_async(client, split_source),
+            str(merge_partner.id): await _fetch_page_count_async(client, merge_partner),
+        }
+        sources: list[PdfMergeInput] = [
+            {
+                "file": split_source,
+                "pages": selection if not requires_override else "1",
+            },
+            {"file": merge_partner, "pages": "1"},
+        ]
+        override_body = {"pages": [str(selection), "1"]} if requires_override else None
+
+        if expect_success:
+            response = await client.merge_pdfs(
+                sources,
+                output_prefix=f"live-async-merge-range-{case_id}",
+                extra_body=override_body,
+            )
+            expected_total_pages = sum(
+                len(
+                    _expand_page_selection(
+                        chosen_selection,
+                        total_pages=source_page_counts[str(file.id)],
+                    )
+                )
+                for file, chosen_selection in (
+                    _extract_merge_entry(entry) for entry in sources
+                )
+            )
+            output_info = await client.query_pdf_info(response.output_file)
+            assert output_info.page_count == expected_total_pages
+        else:
+            with pytest.raises(PdfRestApiError, match=r"(?i)page"):
+                await client.merge_pdfs(
+                    sources,
+                    output_prefix=f"live-async-merge-range-{case_id}",
+                    extra_body=override_body,
+                )

tests/live/test_live_summarize_pdf_text.py

@@ -55,6 +55,33 @@ def test_live_summarize_text_to_file_success(
     assert response.input_id == uploaded.id
 
 
+@pytest.mark.asyncio
+async def test_live_async_summarize_text_to_file_success(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> None:
+    resource = get_test_resource_path("report.pdf")
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        uploaded = (await client.files.create_from_paths([resource]))[0]
+        response = await client.summarize_text_to_file(
+            uploaded,
+            target_word_count=30,
+            summary_format="overview",
+        )
+
+    assert isinstance(response, PdfRestFileBasedResponse)
+    assert response.output_files
+    output_file = response.output_file
+    assert output_file.name.endswith(".md")
+    assert output_file.type == "text/markdown"
+    assert output_file.size > 0
+    assert response.warning is None
+    assert response.input_id == uploaded.id
+
+
 @pytest.mark.asyncio
 async def test_live_async_summarize_text_success(
     pdfrest_api_key: str,

tests/live/test_live_translate_pdf_text.py

@@ -126,3 +126,32 @@ def test_live_translate_pdf_text_file_success(
     assert response.output_language == "fr"
     assert response.source_languages
     assert response.input_id == uploaded.id
+
+
+@pytest.mark.asyncio
+async def test_live_async_translate_pdf_text_file_success(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> None:
+    resource = get_test_resource_path("report.pdf")
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        uploaded = (await client.files.create_from_paths([resource]))[0]
+        response = await client.translate_pdf_text_to_file(
+            uploaded,
+            output_language="de",
+            output_format="plaintext",
+        )
+
+    assert isinstance(response, TranslatePdfTextFileResponse)
+    assert response.output_files
+    output_file = response.output_file
+    assert output_file.name.endswith(".txt")
+    assert output_file.type == "text/plain"
+    assert output_file.size > 0
+    assert response.warning is None
+    assert response.output_language == "de"
+    assert response.source_languages
+    assert response.input_id == uploaded.id