Add Flatten Transparencies

Assisted-by: Codex

Author: datalogics-cgreen

src/pdfrest/client.py

@@ -88,6 +88,7 @@
     PdfRedactionApplyPayload,
     PdfRedactionPreviewPayload,
     PdfRestRawFileResponse,
+    PdfFlattenTransparenciesPayload,
     PdfSplitPayload,
     PdfToExcelPayload,
     PdfToPdfxPayload,
@@ -2552,6 +2553,33 @@ def flatten_pdf_forms(
             timeout=timeout,
         )
 
+    def flatten_transparencies(
+        self,
+        file: PdfRestFile | Sequence[PdfRestFile],
+        *,
+        output: str | None = None,
+        quality: Literal["low", "medium", "high"] = "medium",
+        extra_query: Query | None = None,
+        extra_headers: AnyMapping | None = None,
+        extra_body: Body | None = None,
+        timeout: TimeoutTypes | None = None,
+    ) -> PdfRestFileBasedResponse:
+        """Flatten transparent objects in a PDF."""
+
+        payload: dict[str, Any] = {"files": file, "quality": quality}
+        if output is not None:
+            payload["output"] = output
+
+        return self._post_file_operation(
+            endpoint="/flattened-transparencies-pdf",
+            payload=payload,
+            payload_model=PdfFlattenTransparenciesPayload,
+            extra_query=extra_query,
+            extra_headers=extra_headers,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
     def linearize_pdf(
         self,
         file: PdfRestFile | Sequence[PdfRestFile],
@@ -3425,6 +3453,33 @@ async def flatten_pdf_forms(
             timeout=timeout,
         )
 
+    async def flatten_transparencies(
+        self,
+        file: PdfRestFile | Sequence[PdfRestFile],
+        *,
+        output: str | None = None,
+        quality: Literal["low", "medium", "high"] = "medium",
+        extra_query: Query | None = None,
+        extra_headers: AnyMapping | None = None,
+        extra_body: Body | None = None,
+        timeout: TimeoutTypes | None = None,
+    ) -> PdfRestFileBasedResponse:
+        """Asynchronously flatten transparent objects in a PDF."""
+
+        payload: dict[str, Any] = {"files": file, "quality": quality}
+        if output is not None:
+            payload["output"] = output
+
+        return await self._post_file_operation(
+            endpoint="/flattened-transparencies-pdf",
+            payload=payload,
+            payload_model=PdfFlattenTransparenciesPayload,
+            extra_query=extra_query,
+            extra_headers=extra_headers,
+            extra_body=extra_body,
+            timeout=timeout,
+        )
+
     async def linearize_pdf(
         self,
         file: PdfRestFile | Sequence[PdfRestFile],

src/pdfrest/models/_internal.py

@@ -889,6 +889,31 @@ class PdfLinearizePayload(BaseModel):
     ] = None
 
 
+class PdfFlattenTransparenciesPayload(BaseModel):
+    """Adapt caller options into a pdfRest-ready flatten-transparencies request payload."""
+
+    files: Annotated[
+        list[PdfRestFile],
+        Field(
+            min_length=1,
+            max_length=1,
+            validation_alias=AliasChoices("file", "files"),
+            serialization_alias="id",
+        ),
+        BeforeValidator(_ensure_list),
+        AfterValidator(
+            _allowed_mime_types("application/pdf", error_msg="Must be a PDF file")
+        ),
+        PlainSerializer(_serialize_as_first_file_id),
+    ]
+    output: Annotated[
+        str | None,
+        Field(serialization_alias="output", min_length=1, default=None),
+        AfterValidator(_validate_output_prefix),
+    ] = None
+    quality: Literal["low", "medium", "high"] = "medium"
+
+
 class BmpPdfRestPayload(BasePdfRestGraphicPayload[Literal["rgb", "gray"]]):
     """Adapt caller options into a pdfRest-ready BMP request payload."""
 

tests/live/test_live_flatten_transparencies.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import pytest
+
+from pdfrest import AsyncPdfRestClient, PdfRestApiError, PdfRestClient
+from pdfrest.models import PdfRestFile
+
+from ..resources import get_test_resource_path
+
+
+@pytest.fixture(scope="module")
+def uploaded_pdf_for_transparencies(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+) -> PdfRestFile:
+    resource = get_test_resource_path("report.pdf")
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        return client.files.create_from_paths([resource])[0]
+
+
+@pytest.mark.parametrize(
+    "output_name,quality",
+    [
+        pytest.param(None, "medium", id="default-output"),
+        pytest.param("flatten-transparency", "high", id="custom-output-high"),
+    ],
+)
+def test_live_flatten_transparencies_success(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_transparencies: PdfRestFile,
+    output_name: str | None,
+    quality: str,
+) -> None:
+    kwargs: dict[str, str] = {"quality": quality}
+    if output_name is not None:
+        kwargs["output"] = output_name
+
+    with PdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        response = client.flatten_transparencies(
+            uploaded_pdf_for_transparencies, **kwargs
+        )
+
+    assert response.output_files
+    output_file = response.output_file
+    assert output_file.type == "application/pdf"
+    assert str(response.input_id) == str(uploaded_pdf_for_transparencies.id)
+    if output_name is not None:
+        assert output_file.name.startswith(output_name)
+    else:
+        assert output_file.name.endswith(".pdf")
+
+
+@pytest.mark.asyncio
+async def test_live_async_flatten_transparencies_success(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_transparencies: PdfRestFile,
+) -> None:
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        response = await client.flatten_transparencies(
+            uploaded_pdf_for_transparencies, output="async", quality="low"
+        )
+
+    assert response.output_files
+    output_file = response.output_file
+    assert output_file.name.startswith("async")
+    assert output_file.type == "application/pdf"
+    assert str(response.input_id) == str(uploaded_pdf_for_transparencies.id)
+
+
+def test_live_flatten_transparencies_invalid_file_id(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_transparencies: PdfRestFile,
+) -> None:
+    with (
+        PdfRestClient(
+            api_key=pdfrest_api_key,
+            base_url=pdfrest_live_base_url,
+        ) as client,
+        pytest.raises(PdfRestApiError),
+    ):
+        client.flatten_transparencies(
+            uploaded_pdf_for_transparencies,
+            extra_body={"id": "00000000-0000-0000-0000-000000000000"},
+        )
+
+
+@pytest.mark.asyncio
+async def test_live_async_flatten_transparencies_invalid_file_id(
+    pdfrest_api_key: str,
+    pdfrest_live_base_url: str,
+    uploaded_pdf_for_transparencies: PdfRestFile,
+) -> None:
+    async with AsyncPdfRestClient(
+        api_key=pdfrest_api_key,
+        base_url=pdfrest_live_base_url,
+    ) as client:
+        with pytest.raises(PdfRestApiError):
+            await client.flatten_transparencies(
+                uploaded_pdf_for_transparencies,
+                extra_body={"id": "ffffffff-ffff-ffff-ffff-ffffffffffff"},
+            )