pangea-sdk 4.1.0__py3-none-any.whl → 4.3.0__py3-none-any.whl

pangea/services/authn/models.py

@@ -5,22 +5,62 @@ from __future__ import annotations
 
 import enum
 from typing import Dict, List, NewType, Optional, Union
+from warnings import warn
 
-from pydantic import BaseModel, ConfigDict
+from typing_extensions import deprecated
 
 import pangea.services.intel as im
+from pangea.deprecated import pangea_deprecated
 from pangea.response import APIRequestModel, APIResponseModel, PangeaResponseResult
 from pangea.services.vault.models.common import JWK, JWKec, JWKrsa
 
 Scopes = NewType("Scopes", List[str])
 
 
-class Profile(BaseModel):
-    first_name: str
-    last_name: Optional[str] = None
-    phone: Optional[str] = None
-
-    model_config = ConfigDict(extra="allow")
+class Profile(Dict[str, str]):
+    @property
+    def first_name(self) -> str:
+        warn(
+            '`Profile.first_name` is deprecated. Use `Profile["first_name"]` instead.', DeprecationWarning, stacklevel=2
+        )
+        return self["first_name"]
+
+    @first_name.setter
+    def first_name(self, value: str) -> None:
+        warn(
+            '`Profile.first_name` is deprecated. Use `Profile["first_name"]` instead.', DeprecationWarning, stacklevel=2
+        )
+        self["first_name"] = value
+
+    @property
+    def last_name(self) -> str:
+        warn('`Profile.last_name` is deprecated. Use `Profile["last_name"]` instead.', DeprecationWarning, stacklevel=2)
+        return self["last_name"]
+
+    @last_name.setter
+    def last_name(self, value: str) -> None:
+        warn('`Profile.last_name` is deprecated. Use `Profile["last_name"]` instead.', DeprecationWarning, stacklevel=2)
+        self["last_name"] = value
+
+    @property
+    def phone(self) -> str:
+        warn('`Profile.phone` is deprecated. Use `Profile["phone"]` instead.', DeprecationWarning, stacklevel=2)
+        return self["phone"]
+
+    @phone.setter
+    def phone(self, value: str) -> None:
+        warn('`Profile.phone` is deprecated. Use `Profile["phone"]` instead.', DeprecationWarning, stacklevel=2)
+        self["phone"] = value
+
+    @deprecated("`Profile.model_dump()` is deprecated. `Profile` is already a `dict[str, str]`.")
+    @pangea_deprecated(reason="`Profile` is already a `dict[str, str]`.")
+    def model_dump(self, *, exclude_none: bool = False) -> dict[str, str]:
+        warn(
+            "`Profile.model_dump()` is deprecated. `Profile` is already a `dict[str, str]`.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self
 
 
 class ClientPasswordChangeRequest(APIRequestModel):
@@ -65,7 +105,7 @@ class SessionToken(PangeaResponseResult):
     identity: str
     email: str
     scopes: Optional[Scopes] = None
-    profile: Profile
+    profile: Union[Profile, Dict[str, str]]
     created_at: str
     intelligence: Optional[Intelligence] = None
 
@@ -156,12 +196,43 @@ class UserListOrderBy(enum.Enum):
 
 
 class Authenticator(APIResponseModel):
+    """Authenticator."""
+
     id: str
+    """An ID for an authenticator."""
+
     type: str
+    """An authentication mechanism."""
+
     enabled: bool
+    """Enabled."""
+
     provider: Optional[str] = None
+    """Provider."""
+
+    provider_name: Optional[str] = None
+    """Provider name."""
+
     rpid: Optional[str] = None
+    """RPID."""
+
     phase: Optional[str] = None
+    """Phase."""
+
+    enrolling_browser: Optional[str] = None
+    """Enrolling browser."""
+
+    enrolling_ip: Optional[str] = None
+    """Enrolling IP."""
+
+    created_at: str
+    """A time in ISO-8601 format."""
+
+    updated_at: str
+    """A time in ISO-8601 format."""
+
+    state: Optional[str] = None
+    """State."""
 
 
 class User(PangeaResponseResult):
@@ -174,7 +245,7 @@ class User(PangeaResponseResult):
     username: str
     """A username."""
 
-    profile: Profile
+    profile: Union[Profile, Dict[str, str]]
     """A user profile as a collection of string properties."""
 
     verified: bool
@@ -207,7 +278,7 @@ class UserCreateRequest(APIRequestModel):
     email: str
     """An email address."""
 
-    profile: Profile
+    profile: Union[Profile, Dict[str, str]]
     """A user profile as a collection of string properties."""
 
     username: Optional[str] = None
@@ -397,7 +468,7 @@ class UserProfileGetResult(User):
 
 
 class UserProfileUpdateRequest(APIRequestModel):
-    profile: Profile
+    profile: Union[Profile, Dict[str, str]]
     """Updates to a user profile."""
 
     id: Optional[str] = None
@@ -485,6 +556,7 @@ class UserAuthenticatorsListRequest(APIRequestModel):
 
 class UserAuthenticatorsListResult(PangeaResponseResult):
     authenticators: List[Authenticator] = []
+    """A list of authenticators."""
 
 
 class FlowCompleteRequest(APIRequestModel):
@@ -583,7 +655,7 @@ class FlowUpdateDataPassword(APIRequestModel):
 
 
 class FlowUpdateDataProfile(APIRequestModel):
-    profile: Profile
+    profile: Union[Profile, Dict[str, str]]
 
 
 class FlowUpdateDataProvisionalEnrollment(APIRequestModel):
@@ -705,7 +777,7 @@ class SessionItem(APIResponseModel):
     expire: str
     email: str
     scopes: Optional[Scopes] = None
-    profile: Profile
+    profile: Union[Profile, Dict[str, str]]
     created_at: str
     active_token: Optional[SessionToken] = None
 

pangea/services/authz.py

@@ -132,6 +132,7 @@ class ListResourcesRequest(APIRequestModel):
     type: str
     action: str
     subject: Subject
+    attributes: Optional[Dict[str, Any]] = None
 
 
 class ListResourcesResult(PangeaResponseResult):
@@ -141,6 +142,7 @@ class ListResourcesResult(PangeaResponseResult):
 class ListSubjectsRequest(APIRequestModel):
     resource: Resource
     action: str
+    attributes: Optional[Dict[str, Any]] = None
 
 
 class ListSubjectsResult(PangeaResponseResult):
@@ -278,7 +280,7 @@ class AuthZ(ServiceBase):
         action: str,
         subject: Subject,
         debug: Optional[bool] = None,
-        attributes: Optional[Dict[str, Union[int, str]]] = None,
+        attributes: Optional[Dict[str, Any]] = None,
     ) -> PangeaResponse[CheckResult]:
         """Perform a check request.
 
@@ -289,7 +291,7 @@ class AuthZ(ServiceBase):
             action (str): The action to check.
             subject (Subject): The subject to check.
             debug (Optional[bool]): Setting this value to True will provide a detailed analysis of the check.
-            attributes (Optional[Dict[str, Union[int, str]]]): Additional attributes for the check.
+            attributes (Optional[Dict[str, Any]]): Additional attributes for the check.
 
         Raises:
             PangeaAPIException: If an API Error happens.
@@ -311,8 +313,10 @@ class AuthZ(ServiceBase):
         input_data = CheckRequest(resource=resource, action=action, subject=subject, debug=debug, attributes=attributes)
         return self.request.post("v1/check", CheckResult, data=input_data.model_dump(exclude_none=True))
 
-    def list_resources(self, type: str, action: str, subject: Subject) -> PangeaResponse[ListResourcesResult]:
-        """List resources.
+    def list_resources(
+        self, type: str, action: str, subject: Subject, attributes: Optional[Dict[str, Any]] = None
+    ) -> PangeaResponse[ListResourcesResult]:
+        """List resources. (Beta)
 
         Given a type, action, and subject, list all the resources in the
         type that the subject has access to the action with.
@@ -321,6 +325,7 @@ class AuthZ(ServiceBase):
             type (str): The type to filter resources.
             action (str): The action to filter resources.
             subject (Subject): The subject to filter resources.
+            attributes (Optional[Dict[str, Any]]): A JSON object of attribute data.
 
         Raises:
             PangeaAPIException: If an API Error happens.
@@ -338,13 +343,15 @@ class AuthZ(ServiceBase):
             )
         """
 
-        input_data = ListResourcesRequest(type=type, action=action, subject=subject)
+        input_data = ListResourcesRequest(type=type, action=action, subject=subject, attributes=attributes)
         return self.request.post(
             "v1/list-resources", ListResourcesResult, data=input_data.model_dump(exclude_none=True)
         )
 
-    def list_subjects(self, resource: Resource, action: str) -> PangeaResponse[ListSubjectsResult]:
-        """List subjects.
+    def list_subjects(
+        self, resource: Resource, action: str, attributes: Optional[Dict[str, Any]] = None
+    ) -> PangeaResponse[ListSubjectsResult]:
+        """List subjects. (Beta)
 
         Given a resource and an action, return the list of subjects who have
         access to the action for the given resource.
@@ -352,6 +359,7 @@ class AuthZ(ServiceBase):
         Args:
             resource (Resource): The resource to filter subjects.
             action (str): The action to filter subjects.
+            attributes (Optional[Dict[str, Any]]): A JSON object of attribute data.
 
         Raises:
             PangeaAPIException: If an API Error happens.
@@ -368,5 +376,5 @@ class AuthZ(ServiceBase):
             )
         """
 
-        input_data = ListSubjectsRequest(resource=resource, action=action)
+        input_data = ListSubjectsRequest(resource=resource, action=action, attributes=attributes)
         return self.request.post("v1/list-subjects", ListSubjectsResult, data=input_data.model_dump(exclude_none=True))

pangea/services/file_scan.py

@@ -11,22 +11,25 @@ from pangea.utils import FileUploadParams, get_file_upload_params
 
 
 class FileScanRequest(APIRequestModel):
-    """
-    File Scan request data
-
-    provider (str, optional): Provider of the information. Default provider defined by the configuration.
-    verbose (bool, optional): Echo back the parameters of the API in the response
-    raw (bool, optional): Return additional details from the provider.
-    """
+    """File Scan request data."""
 
     verbose: Optional[bool] = None
+    """Echo back the parameters of the API in the response."""
+
     raw: Optional[bool] = None
+    """Return additional details from the provider."""
+
     provider: Optional[str] = None
+    """Provider of the information. Default provider defined by the configuration."""
+
     size: Optional[int] = None
     crc32c: Optional[str] = None
     sha256: Optional[str] = None
     source_url: Optional[str] = None
+    """A URL where the file to be scanned can be downloaded."""
+
     transfer_method: TransferMethod = TransferMethod.POST_URL
+    """The transfer method used to upload the file data."""
 
 
 class FileScanData(PangeaResponseResult):
@@ -71,7 +74,6 @@ class FileScan(ServiceBase):
     """
 
     service_name = "file-scan"
-    version = "v1"
 
     def file_scan(
         self,
@@ -92,12 +94,14 @@ class FileScan(ServiceBase):
         OperationId: file_scan_post_v1_scan
 
         Args:
-            file (io.BufferedReader, optional): file to be scanned (should be opened with read permissions and in binary format)
             file_path (str, optional): filepath to be opened and scanned
+            file (io.BufferedReader, optional): file to be scanned (should be opened with read permissions and in binary format)
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
             provider (str, optional): Scan file using this provider
             sync_call (bool, optional): True to wait until server returns a result, False to return immediately and retrieve result asynchronously
+            transfer_method (TransferMethod, optional): Transfer method used to upload the file data.
+            source_url (str, optional): A URL where the Pangea APIs can fetch the contents of the input file.
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -118,6 +122,15 @@ class FileScan(ServiceBase):
                     print(f"\\t{err.detail} \\n")
         """
 
+        if transfer_method == TransferMethod.SOURCE_URL and source_url is None:
+            raise ValueError("`source_url` argument is required when using `TransferMethod.SOURCE_URL`.")
+
+        if source_url is not None and transfer_method != TransferMethod.SOURCE_URL:
+            raise ValueError(
+                "`transfer_method` should be `TransferMethod.SOURCE_URL` when using the `source_url` argument."
+            )
+
+        files: Optional[List[Tuple]] = None
         if file or file_path:
             if file_path:
                 file = open(file_path, "rb")
@@ -128,9 +141,9 @@ class FileScan(ServiceBase):
                 size = params.size
             else:
                 crc, sha, size = None, None, None
-            files: List[Tuple] = [("upload", ("filename", file, "application/octet-stream"))]
-        else:
-            raise ValueError("Need to set file_path or file arguments")
+            files = [("upload", ("filename", file, "application/octet-stream"))]
+        elif source_url is None:
+            raise ValueError("Need to set one of `file_path`, `file`, or `source_url` arguments.")
 
         input = FileScanRequest(
             verbose=verbose,
@@ -143,7 +156,11 @@ class FileScan(ServiceBase):
             source_url=source_url,
         )
         data = input.model_dump(exclude_none=True)
-        return self.request.post("v1/scan", FileScanResult, data=data, files=files, poll_result=sync_call)
+        try:
+            return self.request.post("v1/scan", FileScanResult, data=data, files=files, poll_result=sync_call)
+        finally:
+            if file_path and file:
+                file.close()
 
     def request_upload_url(
         self,

pangea/services/sanitize.py

@@ -0,0 +1,335 @@
+# Copyright 2022 Pangea Cyber Corporation
+# Author: Pangea Cyber Corporation
+from __future__ import annotations
+
+import io
+from typing import Dict, List, Optional, Tuple
+
+from pangea.response import APIRequestModel, PangeaResponse, PangeaResponseResult, TransferMethod
+from pangea.services.base import ServiceBase
+from pangea.utils import FileUploadParams, get_file_upload_params
+
+
+class SanitizeFile(APIRequestModel):
+    scan_provider: Optional[str] = None
+    """Provider to use for File Scan."""
+
+
+class SanitizeContent(APIRequestModel):
+    url_intel: Optional[bool] = None
+    """Perform URL Intel lookup."""
+
+    url_intel_provider: Optional[str] = None
+    """Provider to use for URL Intel."""
+
+    domain_intel: Optional[bool] = None
+    """Perform Domain Intel lookup."""
+
+    domain_intel_provider: Optional[str] = None
+    """Provider to use for Domain Intel lookup."""
+
+    defang: Optional[bool] = None
+    """Defang external links."""
+
+    defang_threshold: Optional[int] = None
+    """Defang risk threshold."""
+
+    redact: Optional[bool] = None
+    """Redact sensitive content."""
+
+    remove_attachments: Optional[bool] = None
+    """Remove file attachments (PDF only)."""
+
+    remove_interactive: Optional[bool] = None
+    """Remove interactive content (PDF only)."""
+
+
+class SanitizeShareOutput(APIRequestModel):
+    enabled: Optional[bool] = None
+    """Store Sanitized files to Pangea Secure Share."""
+
+    output_folder: Optional[str] = None
+    """
+    Store Sanitized files to this Secure Share folder (will be auto-created if
+    it does not exist)
+    """
+
+
+class SanitizeRequest(APIRequestModel):
+    transfer_method: TransferMethod = TransferMethod.POST_URL
+    """The transfer method used to upload the file data."""
+
+    source_url: Optional[str] = None
+    """A URL where the file to be sanitized can be downloaded."""
+
+    share_id: Optional[str] = None
+    """A Pangea Secure Share ID where the file to be Sanitized is stored."""
+
+    file: Optional[SanitizeFile] = None
+    """File."""
+
+    content: Optional[SanitizeContent] = None
+    """Content."""
+
+    share_output: Optional[SanitizeShareOutput] = None
+    """Share output."""
+
+    size: Optional[int] = None
+    """The size (in bytes) of the file. If the upload doesn't match, the call will fail."""
+
+    crc32c: Optional[str] = None
+    """The CRC32C hash of the file data, which will be verified by the server if provided."""
+
+    sha256: Optional[str] = None
+    """The hexadecimal-encoded SHA256 hash of the file data, which will be verified by the server if provided."""
+
+    uploaded_file_name: Optional[str] = None
+    """Name of the user-uploaded file, required for transfer-method 'put-url' and 'post-url'."""
+
+
+class DefangData(PangeaResponseResult):
+    external_urls_count: Optional[int] = None
+    """Number of external links found."""
+
+    external_domains_count: Optional[int] = None
+    """Number of external domains found."""
+
+    defanged_count: Optional[int] = None
+    """Number of items defanged per provided rules and detections."""
+
+    url_intel_summary: Optional[str] = None
+    """Processed N URLs: X are malicious, Y are suspicious, Z are unknown."""
+
+    domain_intel_summary: Optional[str] = None
+    """Processed N Domains: X are malicious, Y are suspicious, Z are unknown."""
+
+
+class RedactData(PangeaResponseResult):
+    redaction_count: Optional[int] = None
+    """Number of items redacted"""
+
+    summary_counts: Dict = {}
+    """Summary counts."""
+
+
+class CDR(PangeaResponseResult):
+    file_attachments_removed: Optional[int] = None
+    """Number of file attachments removed."""
+
+    interactive_contents_removed: Optional[int] = None
+    """Number of interactive content items removed."""
+
+
+class SanitizeData(PangeaResponseResult):
+    defang: Optional[DefangData] = None
+    """Defang."""
+
+    redact: Optional[RedactData] = None
+    """Redact."""
+
+    malicious_file: Optional[bool] = None
+    """If the file scanned was malicious."""
+
+    cdr: Optional[CDR] = None
+    """Content Disarm and Reconstruction."""
+
+
+class SanitizeResult(PangeaResponseResult):
+    dest_url: Optional[str] = None
+    """A URL where the Sanitized file can be downloaded."""
+
+    dest_share_id: Optional[str] = None
+    """Pangea Secure Share ID of the Sanitized file."""
+
+    data: SanitizeData
+    """Sanitize data."""
+
+    parameters: Dict = {}
+    """The parameters, which were passed in the request, echoed back."""
+
+
+class Sanitize(ServiceBase):
+    """Sanitize service client.
+
+    Examples:
+        import os
+
+        # Pangea SDK
+        from pangea.config import PangeaConfig
+        from pangea.services import Sanitize
+
+        PANGEA_SANITIZE_TOKEN = os.getenv("PANGEA_SANITIZE_TOKEN")
+        config = PangeaConfig(domain="pangea.cloud")
+
+        sanitize = Sanitize(token=PANGEA_SANITIZE_TOKEN, config=config)
+    """
+
+    service_name = "sanitize"
+
+    def sanitize(
+        self,
+        transfer_method: TransferMethod = TransferMethod.POST_URL,
+        file_path: Optional[str] = None,
+        file: Optional[io.BufferedReader] = None,
+        source_url: Optional[str] = None,
+        share_id: Optional[str] = None,
+        file_scan: Optional[SanitizeFile] = None,
+        content: Optional[SanitizeContent] = None,
+        share_output: Optional[SanitizeShareOutput] = None,
+        size: Optional[int] = None,
+        crc32c: Optional[str] = None,
+        sha256: Optional[str] = None,
+        uploaded_file_name: Optional[str] = None,
+        sync_call: bool = True,
+    ) -> PangeaResponse[SanitizeResult]:
+        """
+        Sanitize
+
+        Apply file sanitization actions according to specified rules.
+
+        OperationId: sanitize_post_v1_sanitize
+
+        Args:
+            transfer_method: The transfer method used to upload the file data.
+            file_path: Path to file to sanitize.
+            file: File to sanitize.
+            source_url: A URL where the file to be sanitized can be downloaded.
+            share_id: A Pangea Secure Share ID where the file to be sanitized is stored.
+            file_scan: Options for File Scan.
+            content: Options for how the file should be sanitized.
+            share_output: Integration with Secure Share.
+            size: The size (in bytes) of the file. If the upload doesn't match, the call will fail.
+            crc32c: The CRC32C hash of the file data, which will be verified by the server if provided.
+            sha256: The hexadecimal-encoded SHA256 hash of the file data, which will be verified by the server if provided.
+            uploaded_file_name: Name of the user-uploaded file, required for `TransferMethod.PUT_URL` and `TransferMethod.POST_URL`.
+            sync_call: Whether or not to poll on HTTP/202.
+
+        Raises:
+            PangeaAPIException: If an API error happens.
+
+        Returns:
+            The sanitized file and information on the sanitization that was
+            performed.
+
+        Examples:
+            with open("/path/to/file.pdf", "rb") as f:
+                response = sanitize.sanitize(
+                    file=f,
+                    transfer_method=TransferMethod.POST_URL,
+                    uploaded_file_name="uploaded_file",
+                )
+        """
+
+        if transfer_method == TransferMethod.SOURCE_URL and source_url is None:
+            raise ValueError("`source_url` argument is required when using `TransferMethod.SOURCE_URL`.")
+
+        if source_url is not None and transfer_method != TransferMethod.SOURCE_URL:
+            raise ValueError(
+                "`transfer_method` should be `TransferMethod.SOURCE_URL` when using the `source_url` argument."
+            )
+
+        files: Optional[List[Tuple]] = None
+        if file or file_path:
+            if file_path:
+                file = open(file_path, "rb")
+            if (
+                transfer_method == TransferMethod.POST_URL
+                and file
+                and (sha256 is None or crc32c is None or size is None)
+            ):
+                params = get_file_upload_params(file)
+                crc32c = params.crc_hex if crc32c is None else crc32c
+                sha256 = params.sha256_hex if sha256 is None else sha256
+                size = params.size if size is None else size
+            else:
+                crc32c, sha256, size = None, None, None
+            files = [("upload", ("filename", file, "application/octet-stream"))]
+        elif source_url is None:
+            raise ValueError("Need to set one of `file_path`, `file`, or `source_url` arguments.")
+
+        input = SanitizeRequest(
+            transfer_method=transfer_method,
+            source_url=source_url,
+            share_id=share_id,
+            file=file_scan,
+            content=content,
+            share_output=share_output,
+            crc32c=crc32c,
+            sha256=sha256,
+            size=size,
+            uploaded_file_name=uploaded_file_name,
+        )
+        data = input.model_dump(exclude_none=True)
+        try:
+            response = self.request.post("v1/sanitize", SanitizeResult, data=data, files=files, poll_result=sync_call)
+        finally:
+            if file_path and file is not None:
+                file.close()
+        return response
+
+    def request_upload_url(
+        self,
+        transfer_method: TransferMethod = TransferMethod.PUT_URL,
+        params: Optional[FileUploadParams] = None,
+        file_scan: Optional[SanitizeFile] = None,
+        content: Optional[SanitizeContent] = None,
+        share_output: Optional[SanitizeShareOutput] = None,
+        size: Optional[int] = None,
+        crc32c: Optional[str] = None,
+        sha256: Optional[str] = None,
+        uploaded_file_name: Optional[str] = None,
+    ) -> PangeaResponse[SanitizeResult]:
+        """
+        Sanitize via presigned URL
+
+        Apply file sanitization actions according to specified rules via a
+        [presigned URL](https://pangea.cloud/docs/api/transfer-methods).
+
+        OperationId: sanitize_post_v1_sanitize 2
+
+        Args:
+            transfer_method: The transfer method used to upload the file data.
+            params: File upload parameters.
+            file_scan: Options for File Scan.
+            content: Options for how the file should be sanitized.
+            share_output: Integration with Secure Share.
+            size: The size (in bytes) of the file. If the upload doesn't match, the call will fail.
+            crc32c: The CRC32C hash of the file data, which will be verified by the server if provided.
+            sha256: The hexadecimal-encoded SHA256 hash of the file data, which will be verified by the server if provided.
+            uploaded_file_name: Name of the user-uploaded file, required for `TransferMethod.PUT_URL` and `TransferMethod.POST_URL`.
+
+        Raises:
+            PangeaAPIException: If an API error happens.
+
+        Returns:
+            A presigned URL.
+
+        Examples:
+            presignedUrl = sanitize.request_upload_url(
+                transfer_method=TransferMethod.PUT_URL,
+                uploaded_file_name="uploaded_file",
+            )
+
+            # Upload file to `presignedUrl.accepted_result.put_url`.
+
+            # Poll for Sanitize's result.
+            response: PangeaResponse[SanitizeResult] = sanitize.poll_result(response=presignedUrl)
+        """
+
+        input = SanitizeRequest(
+            transfer_method=transfer_method,
+            file=file_scan,
+            content=content,
+            share_output=share_output,
+            crc32c=crc32c,
+            sha256=sha256,
+            size=size,
+            uploaded_file_name=uploaded_file_name,
+        )
+        if params is not None and (transfer_method == TransferMethod.POST_URL):
+            input.crc32c = params.crc_hex
+            input.sha256 = params.sha256_hex
+            input.size = params.size
+
+        data = input.model_dump(exclude_none=True)
+        return self.request.request_presigned_url("v1/sanitize", SanitizeResult, data=data)