pangea-sdk 3.8.0__py3-none-any.whl → 5.3.0__py3-none-any.whl

pangea/asyncio/services/intel.py

@@ -67,7 +67,9 @@ class FileIntelAsync(ServiceBaseAsync):
 
         """
         input = m.FileReputationRequest(hash=hash, hash_type=hash_type, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v1/reputation", m.FileReputationResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v1/reputation", m.FileReputationResult, data=input.model_dump(exclude_none=True)
+        )
 
     async def hash_reputation_bulk(
         self,
@@ -103,7 +105,9 @@ class FileIntelAsync(ServiceBaseAsync):
         input = m.FileReputationBulkRequest(  # type: ignore[call-arg]
             hashes=hashes, hash_type=hash_type, verbose=verbose, raw=raw, provider=provider
         )
-        return await self.request.post("v2/reputation", m.FileReputationBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v2/reputation", m.FileReputationBulkResult, data=input.model_dump(exclude_none=True)
+        )
 
     async def filepath_reputation(
         self,
@@ -144,7 +148,9 @@ class FileIntelAsync(ServiceBaseAsync):
         hash = hashlib.sha256(data.read()).hexdigest()
 
         input = m.FileReputationRequest(hash=hash, hash_type="sha256", verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v1/reputation", m.FileReputationResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v1/reputation", m.FileReputationResult, data=input.model_dump(exclude_none=True)
+        )
 
     async def filepath_reputation_bulk(
         self,
@@ -243,7 +249,9 @@ class DomainIntelAsync(ServiceBaseAsync):
             )
         """
         input = m.DomainReputationRequest(domain=domain, verbose=verbose, provider=provider, raw=raw)
-        return await self.request.post("v1/reputation", m.DomainReputationResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v1/reputation", m.DomainReputationResult, data=input.model_dump(exclude_none=True)
+        )
 
     async def reputation_bulk(
         self,
@@ -277,7 +285,7 @@ class DomainIntelAsync(ServiceBaseAsync):
         """
         input = m.DomainReputationBulkRequest(domains=domains, verbose=verbose, provider=provider, raw=raw)
         return await self.request.post(
-            "v2/reputation", m.DomainReputationBulkResult, data=input.dict(exclude_none=True)
+            "v2/reputation", m.DomainReputationBulkResult, data=input.model_dump(exclude_none=True)
         )
 
     async def who_is(
@@ -310,7 +318,7 @@ class DomainIntelAsync(ServiceBaseAsync):
             )
         """
         input = m.DomainWhoIsRequest(domain=domain, verbose=verbose, provider=provider, raw=raw)  # type: ignore[call-arg]
-        return await self.request.post("v1/whois", m.DomainWhoIsResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v1/whois", m.DomainWhoIsResult, data=input.model_dump(exclude_none=True))
 
 
 class IpIntelAsync(ServiceBaseAsync):
@@ -353,7 +361,7 @@ class IpIntelAsync(ServiceBaseAsync):
             ip (str): The IP to be looked up
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -369,7 +377,7 @@ class IpIntelAsync(ServiceBaseAsync):
             )
         """
         input = m.IPReputationRequest(ip=ip, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v1/reputation", m.IPReputationResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v1/reputation", m.IPReputationResult, data=input.model_dump(exclude_none=True))
 
     async def reputation_bulk(
         self, ips: List[str], verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -385,7 +393,7 @@ class IpIntelAsync(ServiceBaseAsync):
             ips (List[str]): The IP list to be looked up
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -398,7 +406,9 @@ class IpIntelAsync(ServiceBaseAsync):
             FIXME:
         """
         input = m.IPReputationBulkRequest(ips=ips, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v2/reputation", m.IPReputationBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v2/reputation", m.IPReputationBulkResult, data=input.model_dump(exclude_none=True)
+        )
 
     async def geolocate(
         self, ip: str, verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -430,7 +440,7 @@ class IpIntelAsync(ServiceBaseAsync):
             )
         """
         input = m.IPGeolocateRequest(ip=ip, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v1/geolocate", m.IPGeolocateResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v1/geolocate", m.IPGeolocateResult, data=input.model_dump(exclude_none=True))
 
     async def geolocate_bulk(
         self, ips: List[str], verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -459,7 +469,9 @@ class IpIntelAsync(ServiceBaseAsync):
             FIXME:
         """
         input = m.IPGeolocateBulkRequest(ips=ips, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v2/geolocate", m.IPGeolocateBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v2/geolocate", m.IPGeolocateBulkResult, data=input.model_dump(exclude_none=True)
+        )
 
     async def get_domain(
         self, ip: str, verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -491,7 +503,7 @@ class IpIntelAsync(ServiceBaseAsync):
             )
         """
         input = m.IPDomainRequest(ip=ip, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v1/domain", m.IPDomainResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v1/domain", m.IPDomainResult, data=input.model_dump(exclude_none=True))
 
     async def get_domain_bulk(
         self, ips: List[str], verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -520,7 +532,7 @@ class IpIntelAsync(ServiceBaseAsync):
             FIXME:
         """
         input = m.IPDomainBulkRequest(ips=ips, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v2/domain", m.IPDomainBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v2/domain", m.IPDomainBulkResult, data=input.model_dump(exclude_none=True))
 
     async def is_vpn(
         self, ip: str, verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -552,7 +564,7 @@ class IpIntelAsync(ServiceBaseAsync):
             )
         """
         input = m.IPVPNRequest(ip=ip, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v1/vpn", m.IPVPNResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v1/vpn", m.IPVPNResult, data=input.model_dump(exclude_none=True))
 
     async def is_vpn_bulk(
         self, ips: List[str], verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -581,7 +593,7 @@ class IpIntelAsync(ServiceBaseAsync):
             FIXME:
         """
         input = m.IPVPNBulkRequest(ips=ips, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v2/vpn", m.IPVPNBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v2/vpn", m.IPVPNBulkResult, data=input.model_dump(exclude_none=True))
 
     async def is_proxy(
         self, ip: str, verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -613,7 +625,7 @@ class IpIntelAsync(ServiceBaseAsync):
             )
         """
         input = m.IPProxyRequest(ip=ip, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v1/proxy", m.IPProxyResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v1/proxy", m.IPProxyResult, data=input.model_dump(exclude_none=True))
 
     async def is_proxy_bulk(
         self, ips: List[str], verbose: Optional[bool] = None, raw: Optional[bool] = None, provider: Optional[str] = None
@@ -642,7 +654,7 @@ class IpIntelAsync(ServiceBaseAsync):
             FIXME:
         """
         input = m.IPProxyBulkRequest(ips=ips, verbose=verbose, raw=raw, provider=provider)
-        return await self.request.post("v2/proxy", m.IPProxyBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v2/proxy", m.IPProxyBulkResult, data=input.model_dump(exclude_none=True))
 
 
 class UrlIntelAsync(ServiceBaseAsync):
@@ -685,7 +697,7 @@ class UrlIntelAsync(ServiceBaseAsync):
             url (str): The URL to be looked up
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -702,7 +714,7 @@ class UrlIntelAsync(ServiceBaseAsync):
         """
 
         input = m.URLReputationRequest(url=url, provider=provider, verbose=verbose, raw=raw)
-        return await self.request.post("v1/reputation", m.URLReputationResult, data=input.dict(exclude_none=True))
+        return await self.request.post("v1/reputation", m.URLReputationResult, data=input.model_dump(exclude_none=True))
 
     async def reputation_bulk(
         self,
@@ -722,7 +734,7 @@ class UrlIntelAsync(ServiceBaseAsync):
             urls (List[str]): The URL list to be looked up
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -736,7 +748,9 @@ class UrlIntelAsync(ServiceBaseAsync):
         """
 
         input = m.URLReputationBulkRequest(urls=urls, provider=provider, verbose=verbose, raw=raw)
-        return await self.request.post("v2/reputation", m.URLReputationBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v2/reputation", m.URLReputationBulkResult, data=input.model_dump(exclude_none=True)
+        )
 
 
 class UserIntelAsync(ServiceBaseAsync):
@@ -776,6 +790,7 @@ class UserIntelAsync(ServiceBaseAsync):
         verbose: Optional[bool] = None,
         raw: Optional[bool] = None,
         provider: Optional[str] = None,
+        cursor: Optional[str] = None,
     ) -> PangeaResponse[m.UserBreachedResult]:
         """
         Look up breached users
@@ -793,7 +808,8 @@ class UserIntelAsync(ServiceBaseAsync):
             end (str): Latest date for search
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
+            cursor (str, optional): A token given in the raw response from SpyCloud. Post this back to paginate results
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -821,8 +837,11 @@ class UserIntelAsync(ServiceBaseAsync):
             end=end,
             verbose=verbose,
             raw=raw,
+            cursor=cursor,
+        )
+        return await self.request.post(
+            "v1/user/breached", m.UserBreachedResult, data=input.model_dump(exclude_none=True)
         )
-        return await self.request.post("v1/user/breached", m.UserBreachedResult, data=input.dict(exclude_none=True))
 
     async def user_breached_bulk(
         self,
@@ -830,6 +849,7 @@ class UserIntelAsync(ServiceBaseAsync):
         usernames: Optional[List[str]] = None,
         ips: Optional[List[str]] = None,
         phone_numbers: Optional[List[str]] = None,
+        domains: Optional[List[str]] = None,
         start: Optional[str] = None,
         end: Optional[str] = None,
         verbose: Optional[bool] = None,
@@ -848,11 +868,12 @@ class UserIntelAsync(ServiceBaseAsync):
             usernames (List[str]): An username's list to search for
             ips (List[str]): An ip's list to search for
             phone_numbers (List[str]): A phone number's list to search for. minLength: 7, maxLength: 15.
+            domains (List[str]): Search for user under these domains.
             start (str): Earliest date for search
             end (str): Latest date for search
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -870,13 +891,16 @@ class UserIntelAsync(ServiceBaseAsync):
             phone_numbers=phone_numbers,
             usernames=usernames,
             ips=ips,
+            domains=domains,
             provider=provider,
             start=start,
             end=end,
             verbose=verbose,
             raw=raw,
         )
-        return await self.request.post("v2/user/breached", m.UserBreachedBulkResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v2/user/breached", m.UserBreachedBulkResult, data=input.model_dump(exclude_none=True)
+        )
 
     async def password_breached(
         self,
@@ -898,7 +922,7 @@ class UserIntelAsync(ServiceBaseAsync):
             hash_prefix (str): The prefix of the hash to be looked up.
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -919,7 +943,7 @@ class UserIntelAsync(ServiceBaseAsync):
             hash_type=hash_type, hash_prefix=hash_prefix, provider=provider, verbose=verbose, raw=raw
         )
         return await self.request.post(
-            "v1/password/breached", m.UserPasswordBreachedResult, data=input.dict(exclude_none=True)
+            "v1/password/breached", m.UserPasswordBreachedResult, data=input.model_dump(exclude_none=True)
         )
 
     async def password_breached_bulk(
@@ -942,7 +966,7 @@ class UserIntelAsync(ServiceBaseAsync):
             hash_prefixes (List[str]): The list of prefixes of the hash to be looked up.
             verbose (bool, optional): Echo the API parameters in the response
             raw (bool, optional): Include raw data from this provider
-            provider (str, optional): Use reputation data from this provider: "crowdstrike"
+            provider (str, optional): Use reputation data from this provider
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -959,5 +983,55 @@ class UserIntelAsync(ServiceBaseAsync):
             hash_type=hash_type, hash_prefixes=hash_prefixes, provider=provider, verbose=verbose, raw=raw
         )
         return await self.request.post(
-            "v2/password/breached", m.UserPasswordBreachedBulkResult, data=input.dict(exclude_none=True)
+            "v2/password/breached", m.UserPasswordBreachedBulkResult, data=input.model_dump(exclude_none=True)
+        )
+
+    async def breach(
+        self,
+        breach_id: str,
+        verbose: Optional[bool] = None,
+        provider: Optional[str] = None,
+        cursor: Optional[str] = None,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        severity: Optional[List[int]] = None,
+    ) -> PangeaResponse[m.BreachResult]:
+        """
+        Look up information about a specific breach
+
+        Given a provider specific breach ID, find details about the breach.
+
+        OperationId: user_intel_post_v1_breach
+
+        Args:
+            breach_id (str, optional): The ID of a breach returned by a provider
+            verbose (bool, optional): Echo the API parameters in the response
+            provider (str, optional): Use reputation data from this provider
+            cursor (str, optional): A token given in the raw response from SpyCloud. Post this back to paginate results
+            start (str, optional): This parameter allows you to define the starting point for a date range query on the spycloud_publish_date field
+            end (str, optional): This parameter allows you to define the ending point for a date range query on the spycloud_publish_date field
+            severity (List[int], optional): Filter for records that match one of the given severities
+
+        Raises:
+            PangeaAPIException: If an API Error happens
+
+        Returns:
+            A PangeaResponse where the breach details are in the
+                response.result field.  Available response fields can be found in our [API documentation](https://pangea.cloud/docs/api/user-intel)
+
+        Examples:
+            response = await user_intel.breach(
+                breach_id="66111",
+            )
+        """
+
+        input = m.BreachRequest(
+            breach_id=breach_id,
+            provider=provider,
+            verbose=verbose,
+            cursor=cursor,
+            start=start,
+            end=end,
+            severity=severity,
         )
+        return await self.request.post("v1/breach", m.BreachResult, data=input.model_dump(exclude_none=True))

pangea/asyncio/services/redact.py

@@ -64,6 +64,9 @@ class RedactAsync(ServiceBaseAsync):
         rules: Optional[List[str]] = None,
         rulesets: Optional[List[str]] = None,
         return_result: Optional[bool] = None,
+        redaction_method_overrides: Optional[m.RedactionMethodOverrides] = None,
+        llm_request: Optional[bool] = None,
+        vault_parameters: Optional[m.VaultParameters] = None,
     ) -> PangeaResponse[m.RedactResult]:
         """
         Redact
@@ -79,6 +82,9 @@ class RedactAsync(ServiceBaseAsync):
             rules (list[str], optional): An array of redact rule short names
             rulesets (list[str], optional): An array of redact rulesets short names
             return_result(bool, optional): Setting this value to false will omit the redacted result only returning count
+            redaction_method_overrides: A set of redaction method overrides for any enabled rule. These methods override the config declared methods
+            llm_request: Boolean flag to enable FPE redaction for LLM requests
+            vault_parameters: A set of vault parameters to use for redaction
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -92,8 +98,17 @@ class RedactAsync(ServiceBaseAsync):
             response = redact.redact(text="Jenny Jenny... 555-867-5309")
         """
 
-        input = m.RedactRequest(text=text, debug=debug, rules=rules, rulesets=rulesets, return_result=return_result)
-        return await self.request.post("v1/redact", m.RedactResult, data=input.dict(exclude_none=True))
+        input = m.RedactRequest(
+            text=text,
+            debug=debug,
+            rules=rules,
+            rulesets=rulesets,
+            return_result=return_result,
+            redaction_method_overrides=redaction_method_overrides,
+            llm_request=llm_request,
+            vault_parameters=vault_parameters,
+        )
+        return await self.request.post("v1/redact", m.RedactResult, data=input.model_dump(exclude_none=True))
 
     async def redact_structured(
         self,
@@ -104,6 +119,9 @@ class RedactAsync(ServiceBaseAsync):
         rules: Optional[List[str]] = None,
         rulesets: Optional[List[str]] = None,
         return_result: Optional[bool] = None,
+        redaction_method_overrides: Optional[m.RedactionMethodOverrides] = None,
+        llm_request: bool | None = None,
+        vault_parameters: m.VaultParameters | None = None,
     ) -> PangeaResponse[m.StructuredResult]:
         """
         Redact structured
@@ -123,6 +141,9 @@ class RedactAsync(ServiceBaseAsync):
             rules (list[str], optional): An array of redact rule short names
             rulesets (list[str], optional): An array of redact rulesets short names
             return_result(bool, optional): Setting this value to false will omit the redacted result only returning count
+            redaction_method_overrides: A set of redaction method overrides for any enabled rule. These methods override the config declared methods
+            llm_request: Boolean flag to enable FPE redaction for LLM requests
+            vault_parameters: A set of vault parameters to use for redaction
 
         Raises:
             PangeaAPIException: If an API Error happens
@@ -149,5 +170,33 @@ class RedactAsync(ServiceBaseAsync):
             rules=rules,
             rulesets=rulesets,
             return_result=return_result,
+            redaction_method_overrides=redaction_method_overrides,
+            llm_request=llm_request,
+            vault_parameters=vault_parameters,
         )
-        return await self.request.post("v1/redact_structured", m.StructuredResult, data=input.dict(exclude_none=True))
+        return await self.request.post(
+            "v1/redact_structured", m.StructuredResult, data=input.model_dump(exclude_none=True)
+        )
+
+    async def unredact(self, redacted_data: m.RedactedData, fpe_context: str) -> PangeaResponse[m.UnredactResult]:
+        """
+        Unredact
+
+        Decrypt or unredact fpe redactions
+
+        OperationId: redact_post_v1_unredact
+
+        Args:
+            redacted_data: Data to unredact
+            fpe_context (base64): FPE context used to decrypt and unredact data
+
+        Raises:
+            PangeaAPIException: If an API Error happens
+
+        Returns:
+            Pangea Response with redacted data in the response.result field,
+                available response fields can be found in our
+                [API Documentation](https://pangea.cloud/docs/api/redact#unredact)
+        """
+        input = m.UnredactRequest(redacted_data=redacted_data, fpe_context=fpe_context)
+        return await self.request.post("v1/unredact", m.UnredactResult, data=input.model_dump(exclude_none=True))

pangea/asyncio/services/sanitize.py

@@ -0,0 +1,217 @@
+# Copyright 2022 Pangea Cyber Corporation
+# Author: Pangea Cyber Corporation
+from __future__ import annotations
+
+import io
+from typing import List, Optional, Tuple
+
+import pangea.services.sanitize as m
+from pangea.asyncio.services.base import ServiceBaseAsync
+from pangea.config import PangeaConfig
+from pangea.response import PangeaResponse, TransferMethod
+from pangea.utils import FileUploadParams, get_file_upload_params
+
+
+class SanitizeAsync(ServiceBaseAsync):
+    """Sanitize service client.
+
+    Examples:
+        import os
+
+        # Pangea SDK
+        from pangea.asyncio.services import SanitizeAsync
+        from pangea.config import PangeaConfig
+
+        PANGEA_SANITIZE_TOKEN = os.getenv("PANGEA_SANITIZE_TOKEN")
+        config = PangeaConfig(domain="pangea.cloud")
+
+        sanitize = SanitizeAsync(token=PANGEA_SANITIZE_TOKEN, config=config)
+    """
+
+    service_name = "sanitize"
+
+    def __init__(
+        self, token: str, config: PangeaConfig | None = None, logger_name: str = "pangea", config_id: str | None = None
+    ) -> None:
+        """
+        Sanitize client
+
+        Initializes a new Sanitize client.
+
+        Args:
+            token: Pangea API token.
+            config: Configuration.
+            logger_name: Logger name.
+            config_id: Configuration ID.
+
+        Examples:
+             config = PangeaConfig(domain="aws.us.pangea.cloud")
+             authz = SanitizeAsync(token="pangea_token", config=config)
+        """
+
+        super().__init__(token, config, logger_name, config_id=config_id)
+
+    async 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[m.SanitizeFile] = None,
+        content: Optional[m.SanitizeContent] = None,
+        share_output: Optional[m.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[m.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 = await 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 (sha256 is None or crc32c is None or size is None):
+                params = get_file_upload_params(file)  # type: ignore[arg-type]
+                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 = m.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:
+            return await self.request.post(
+                "v1/sanitize", m.SanitizeResult, data=data, files=files, poll_result=sync_call
+            )
+        finally:
+            if file_path and file is not None:
+                file.close()
+
+    async def request_upload_url(
+        self,
+        transfer_method: TransferMethod = TransferMethod.PUT_URL,
+        params: Optional[FileUploadParams] = None,
+        file_scan: Optional[m.SanitizeFile] = None,
+        content: Optional[m.SanitizeContent] = None,
+        share_output: Optional[m.SanitizeShareOutput] = None,
+        size: Optional[int] = None,
+        crc32c: Optional[str] = None,
+        sha256: Optional[str] = None,
+        uploaded_file_name: Optional[str] = None,
+    ) -> PangeaResponse[m.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 = await 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] = await sanitize.poll_result(response=presignedUrl)
+        """
+
+        input = m.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 await self.request.request_presigned_url("v1/sanitize", m.SanitizeResult, data=data)