finish on testing

Author: HungKNguyen

src/nutrient_dws/builder/builder.py

@@ -151,11 +151,7 @@ def _is_action_with_file_input(
         Returns:
             True if action needs file registration
         """
-        return (
-            hasattr(action, "__needsFileRegistration")
-            and hasattr(action, "fileInput")
-            and hasattr(action, "createAction")
-        )
+        return hasattr(action, "createAction")
 
     async def _prepare_files(self) -> dict[str, NormalizedFileData]:
         """Prepare files for the request concurrently.

src/nutrient_dws/builder/staged_builders.py

@@ -58,7 +58,7 @@ class BufferOutput(TypedDict):
 
 
 class ContentOutput(TypedDict):
-    content: str
+    content: bytes
     mimeType: str
     filename: str | None
 

src/nutrient_dws/client.py

@@ -15,7 +15,12 @@
     WorkflowWithPartsStage,
 )
 from nutrient_dws.errors import NutrientError, ValidationError
-from nutrient_dws.http import NutrientClientOptions, SignRequestOptions, send_request
+from nutrient_dws.http import (
+    NutrientClientOptions,
+    SignRequestData,
+    SignRequestOptions,
+    send_request,
+)
 from nutrient_dws.inputs import (
     FileInput,
     get_pdf_page_count,
@@ -362,7 +367,7 @@ async def sign(
             {
                 "method": "POST",
                 "endpoint": "/sign",
-                "data": cast("Any", request_data),
+                "data": cast("SignRequestData", request_data),
                 "headers": None,
             },
             self.options,

src/nutrient_dws/http.py

@@ -256,8 +256,10 @@ def prepare_request_body(
                 files, "graphicImage", config["data"]["graphicImage"]
             )
 
+        request_config["files"] = files
+
         data = {}
-        if "data" in config["data"]:
+        if "data" in config["data"] and config["data"]["data"] is not None:
             data["data"] = json.dumps(config["data"]["data"])
         else:
             data["data"] = json.dumps(
@@ -267,25 +269,22 @@ def prepare_request_body(
                 }
             )
 
-        request_config["files"] = files
         request_config["data"] = data
 
         return request_config
 
     if is_post_ai_redact_request_config(config):
-        typed_config = config
-
-        if "file" in typed_config["data"] and "fileKey" in typed_config["data"]:
+        if "file" in config["data"] and "fileKey" in config["data"]:
             files = {}
             append_file_to_form_data(
-                files, typed_config["data"]["fileKey"], typed_config["data"]["file"]
+                files, config["data"]["fileKey"], config["data"]["file"]
             )
 
             request_config["files"] = files
-            request_config["data"] = {"data": json.dumps(typed_config["data"]["data"])}
+            request_config["data"] = {"data": json.dumps(config["data"]["data"])}
         else:
             # JSON only request
-            request_config["json"] = typed_config["data"]["data"]
+            request_config["json"] = config["data"]["data"]
 
         return request_config
 

src/nutrient_dws/types/build_output.py

@@ -1,14 +1,12 @@
-from typing import Literal, Optional, TypedDict, Union
+from typing import Literal, TypedDict, Union
 
 from typing_extensions import NotRequired
 
 from nutrient_dws.types.misc import OcrLanguage, PageRange
 
-Title = Optional[str]
-
 
 class Metadata(TypedDict):
-    title: NotRequired[Title | None]
+    title: NotRequired[str]
     author: NotRequired[str]
 
 
@@ -59,7 +57,9 @@ class PDFOutput(BasePDFOutput):
 
 class PDFAOutputOptions(PDFOutputOptions):
     conformance: NotRequired[
-        Literal["pdfa-1a", "pdfa-1b", "pdfa-2a", "pdfa-2u", "pdfa-2b", "pdfa-3a", "pdfa-3u"]
+        Literal[
+            "pdfa-1a", "pdfa-1b", "pdfa-2a", "pdfa-2u", "pdfa-2b", "pdfa-3a", "pdfa-3u"
+        ]
     ]
     vectorization: NotRequired[bool]
     rasterization: NotRequired[bool]

src/nutrient_dws/types/instant_json/form_field.py

@@ -49,7 +49,9 @@ class FormFieldAdditionalActionsInput(TypedDict):
     onFormat: NotRequired[Action]
 
 
-class AdditionalActions(FormFieldAdditionalActionsEvent, FormFieldAdditionalActionsInput):
+class AdditionalActions(
+    FormFieldAdditionalActionsEvent, FormFieldAdditionalActionsInput
+):
     pass
 
 

src/nutrient_dws/types/misc.py

@@ -28,7 +28,8 @@ class Margin(TypedDict):
 class PageLayout(TypedDict):
     orientation: NotRequired[Literal["portrait", "landscape"]]
     size: NotRequired[
-        Literal["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "Letter", "Legal"] | Size
+        Literal["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "Letter", "Legal"]
+        | Size
     ]
     margin: NotRequired[Margin]
 
@@ -247,7 +248,9 @@ class WatermarkDimension(TypedDict):
     "MeasurementScale",
     {
         "unitFrom": NotRequired[Literal["in", "mm", "cm", "pt"]],
-        "unitTo": NotRequired[Literal["in", "mm", "cm", "pt", "ft", "m", "yd", "km", "mi"]],
+        "unitTo": NotRequired[
+            Literal["in", "mm", "cm", "pt", "ft", "m", "yd", "km", "mi"]
+        ],
         "from": NotRequired[float],
         "to": NotRequired[float],
     },

src/nutrient_dws/types/sign_request.py

@@ -4,7 +4,9 @@
 
 
 class Appearance(TypedDict):
-    mode: NotRequired[Literal["signatureOnly", "signatureAndDescription", "descriptionOnly"]]
+    mode: NotRequired[
+        Literal["signatureOnly", "signatureAndDescription", "descriptionOnly"]
+    ]
     contentType: NotRequired[str]
     showWatermark: NotRequired[bool]
     showSignDate: NotRequired[bool]

tests/helpers.py

@@ -1,16 +1,19 @@
 """Test utilities and helpers for Nutrient DWS Python Client tests."""
+
 from datetime import datetime, timezone
 import json
 from typing import Any, Optional, TypedDict, Literal, List
 from pathlib import Path
 
+
 class XfdfAnnotation(TypedDict):
-    type: Literal['highlight', 'text', 'square', 'circle']
+    type: Literal["highlight", "text", "square", "circle"]
     page: int
     rect: List[int]
     content: Optional[str]
     color: Optional[str]
 
+
 class TestDocumentGenerator:
     """Generate test documents and content for testing purposes."""
 
@@ -65,10 +68,17 @@ def generate_pdf_with_table() -> bytes:
         return TestDocumentGenerator.generate_simple_pdf_content(content)
 
     @staticmethod
-    def generate_html_content(title: str = "Test Document", include_styles: bool = True, include_table: bool = False, include_images: bool = False, include_form: bool = False) -> bytes:
+    def generate_html_content(
+        title: str = "Test Document",
+        include_styles: bool = True,
+        include_table: bool = False,
+        include_images: bool = False,
+        include_form: bool = False,
+    ) -> bytes:
         """Generate HTML content for testing."""
 
-        styles = """<style>
+        styles = (
+            """<style>
 body {
     font-family: Arial, sans-serif;
     margin: 40px;
@@ -110,8 +120,12 @@ def generate_html_content(title: str = "Test Document", include_styles: bool = T
     border: 1px solid #ddd;
     border-radius: 4px;
 }
-</style>""" if include_styles else ""
-        tables = """<h2>Data Table</h2>
+</style>"""
+            if include_styles
+            else ""
+        )
+        tables = (
+            """<h2>Data Table</h2>
 <table>
     <thead>
         <tr>
@@ -141,13 +155,21 @@ def generate_html_content(title: str = "Test Document", include_styles: bool = T
             <td>$40.00</td>
         </tr>
     </tbody>
-</table>""" if include_table else ""
-        images = """<h2>Images</h2>
+</table>"""
+            if include_table
+            else ""
+        )
+        images = (
+            """<h2>Images</h2>
 <p>Below is a placeholder for image content:</p>
 <div style="width: 200px; height: 200px; background-color: #e0e0e0; display: flex; align-items: center; justify-content: center; margin: 20px 0;">
     <span style="color: #666;">Image Placeholder</span>
-</div>""" if include_images else ""
-        form = """<h2>Form Example</h2>
+</div>"""
+            if include_images
+            else ""
+        )
+        form = (
+            """<h2>Form Example</h2>
 <form>
     <div class="form-group">
         <label for="name">Name:</label>
@@ -161,7 +183,10 @@ def generate_html_content(title: str = "Test Document", include_styles: bool = T
         <label for="message">Message:</label>
         <textarea id="message" name="message" rows="4" placeholder="Enter your message"></textarea>
     </div>
-</form>""" if include_form else ""
+</form>"""
+            if include_form
+            else ""
+        )
 
         html = f"""<!DOCTYPE html>
 <html lang="en">
@@ -180,17 +205,19 @@ def generate_html_content(title: str = "Test Document", include_styles: bool = T
         return html.encode("utf-8")
 
     @staticmethod
-    def generate_xfdf_content(annotations: Optional[list[XfdfAnnotation]] = None) -> bytes:
+    def generate_xfdf_content(
+        annotations: Optional[list[XfdfAnnotation]] = None,
+    ) -> bytes:
         """Generate XFDF annotation content."""
 
         if annotations is None:
             annotations = [
                 {
-                    "type": 'highlight',
+                    "type": "highlight",
                     "page": 0,
                     "rect": [100, 100, 200, 150],
-                    "color": '#FFFF00',
-                    "content": 'Important text',
+                    "color": "#FFFF00",
+                    "content": "Important text",
                 },
             ]
 
@@ -201,11 +228,11 @@ def generate_xfdf_content(annotations: Optional[list[XfdfAnnotation]] = None) ->
             color = annot["color"] or "#FFFF00"
             if annot["type"] == "highlight":
                 inner_xfdf = f"""<highlight page="${annot["page"]}" rect="${rectStr}" color="${color}">
-                            <contents>${annot.get("content", 'Highlighted text')}</contents>
+                            <contents>${annot.get("content", "Highlighted text")}</contents>
                         </highlight>"""
             elif annot["type"] == "text":
                 inner_xfdf = f"""<text page="${annot["page"]}" rect="${rectStr}" color="${color}">
-                            <contents>${annot.get("content", 'Note')}</contents>
+                            <contents>${annot.get("content", "Note")}</contents>
                         </text>"""
             elif annot["type"] == "square":
                 inner_xfdf = f"""<square page="{annot["page"]}" rect="{rectStr}" color="{color}" />"""
@@ -224,17 +251,19 @@ def generate_xfdf_content(annotations: Optional[list[XfdfAnnotation]] = None) ->
     @staticmethod
     def generate_instant_json_content(annotations: Optional[list] = None) -> bytes:
         """Generate Instant JSON annotation content."""
-        annotations = annotations or [{
-        "v": 2,
-        "type": 'pspdfkit/text',
-        "pageIndex": 0,
-        "bbox": [100, 100, 200, 150],
-        "content": 'Test annotation',
-        "fontSize": 14,
-        "opacity": 1,
-        "horizontalAlign": 'left',
-        "verticalAlign": 'top',
-      }]
+        annotations = annotations or [
+            {
+                "v": 2,
+                "type": "pspdfkit/text",
+                "pageIndex": 0,
+                "bbox": [100, 100, 200, 150],
+                "content": "Test annotation",
+                "fontSize": 14,
+                "opacity": 1,
+                "horizontalAlign": "left",
+                "verticalAlign": "top",
+            }
+        ]
         instant_data = {
             "format": "https://pspdfkit.com/instant-json/v1",
             "annotations": [],
@@ -282,7 +311,7 @@ def validate_pdf_output(result: Any) -> None:
 
     @staticmethod
     def validate_office_output(
-            result: Any, format: Literal["docx", "xlsx", "pptx"]
+        result: Any, format: Literal["docx", "xlsx", "pptx"]
     ) -> None:
         """Validates Office document output"""
         mime_types = {
@@ -291,7 +320,11 @@ def validate_office_output(
             "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
         }
 
-        if not isinstance(result, dict) or not result.get("success") or "output" not in result:
+        if (
+            not isinstance(result, dict)
+            or not result.get("success")
+            or "output" not in result
+        ):
             raise ValueError("Result must be successful with output")
 
         output = result["output"]
@@ -307,7 +340,11 @@ def validate_image_output(
         result: Any, format: Literal["png", "jpeg", "jpg", "webp"] | None = None
     ) -> None:
         """Validates image output"""
-        if not isinstance(result, dict) or not result.get("success") or "output" not in result:
+        if (
+            not isinstance(result, dict)
+            or not result.get("success")
+            or "output" not in result
+        ):
             raise ValueError("Result must be successful with output")
 
         output = result["output"]
@@ -325,15 +362,23 @@ def validate_image_output(
             }
             valid_mimes = format_mime_types.get(format, [f"image/{format}"])
             if output.get("mimeType") not in valid_mimes:
-                raise ValueError(f"Expected format {format}, got {output.get('mimeType')}")
+                raise ValueError(
+                    f"Expected format {format}, got {output.get('mimeType')}"
+                )
         else:
-            if not isinstance(output.get("mimeType"), str) or not output["mimeType"].startswith("image/"):
+            if not isinstance(output.get("mimeType"), str) or not output[
+                "mimeType"
+            ].startswith("image/"):
                 raise ValueError("Expected image MIME type")
 
     @staticmethod
     def validate_json_output(result: Any) -> None:
         """Validates JSON extraction output"""
-        if not isinstance(result, dict) or not result.get("success") or "output" not in result:
+        if (
+            not isinstance(result, dict)
+            or not result.get("success")
+            or "output" not in result
+        ):
             raise ValueError("Result must be successful with output")
 
         output = result["output"]
@@ -343,7 +388,9 @@ def validate_json_output(result: Any) -> None:
             raise ValueError("Output data must be an object")
 
     @staticmethod
-    def validate_error_response(result: Any, expected_error_type: str | None = None) -> None:
+    def validate_error_response(
+        result: Any, expected_error_type: str | None = None
+    ) -> None:
         """Validates error response"""
         if not isinstance(result, dict):
             raise ValueError("Result must be a dictionary")