pangea-sdk 6.3.0__py3-none-any.whl → 6.5.0b1__py3-none-any.whl

pangea/asyncio/services/redact.py

@@ -6,12 +6,15 @@
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional, Union
+from collections.abc import Mapping, Sequence
+from typing import Dict, List, Literal, Optional, Union, cast, overload
+
+from pydantic import TypeAdapter
 
 import pangea.services.redact as m
 from pangea.asyncio.services.base import ServiceBaseAsync
 from pangea.config import PangeaConfig
-from pangea.response import PangeaResponse
+from pangea.response import PangeaResponse, PangeaResponseResult
 
 
 class RedactAsync(ServiceBaseAsync):
@@ -68,7 +71,7 @@ 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,
+        redaction_method_overrides: Mapping[str, m.RedactionMethodOverrides] | None = None,
         llm_request: Optional[bool] = None,
         vault_parameters: Optional[m.VaultParameters] = None,
     ) -> PangeaResponse[m.RedactResult]:
@@ -123,7 +126,7 @@ 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,
+        redaction_method_overrides: Mapping[str, m.RedactionMethodOverrides] | None = None,
         llm_request: bool | None = None,
         vault_parameters: m.VaultParameters | None = None,
     ) -> PangeaResponse[m.StructuredResult]:
@@ -204,3 +207,261 @@ class RedactAsync(ServiceBaseAsync):
         """
         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))
+
+    async def get_service_config(self, config_id: str) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Get a service config.
+
+
+        OperationId: redact_post_v1beta_config
+        """
+        response = await self.request.post("v1beta/config", PangeaResponseResult, data={"id": config_id})
+        response.result = TypeAdapter(m.ServiceConfigResult).validate_python(response.json["result"])
+        return cast(PangeaResponse[m.ServiceConfigResult], response)
+
+    @overload
+    async def create_service_config(
+        self,
+        name: str,
+        *,
+        version: Literal["1.0.0"],
+        enabled_rules: Sequence[str] | None = None,
+        redactions: Mapping[str, m.Redaction] | None = None,
+        vault_service_config_id: str | None = None,
+        salt_vault_secret_id: str | None = None,
+        rules: Mapping[str, m.RuleV1] | None = None,
+        rulesets: Mapping[str, m.RulesetV1] | None = None,
+        supported_languages: Sequence[Literal["en"]] | None = None,
+    ) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Create a v1.0.0 service config.
+
+        OperationId: redact_post_v1beta_config_create
+
+        Args:
+            vault_service_config_id: Service config used to create the secret
+            salt_vault_secret_id: Pangea only allows hashing to be done using a salt value to prevent brute-force attacks.
+        """
+
+    @overload
+    async def create_service_config(
+        self,
+        name: str,
+        *,
+        version: Literal["2.0.0"] | None = None,
+        enabled_rules: Sequence[str] | None = None,
+        enforce_enabled_rules: bool | None = None,
+        redactions: Mapping[str, m.Redaction] | None = None,
+        vault_service_config_id: str | None = None,
+        salt_vault_secret_id: str | None = None,
+        fpe_vault_secret_id: str | None = None,
+        rules: Mapping[str, m.RuleV2] | None = None,
+        rulesets: Mapping[str, m.RulesetV2] | None = None,
+        supported_languages: Sequence[Literal["en"]] | None = None,
+    ) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Create a v2.0.0 service config.
+
+        OperationId: redact_post_v1beta_config_create
+
+        Args:
+            enforce_enabled_rules: Always run service config enabled rules across all redact calls regardless of flags?
+            vault_service_config_id: Service config used to create the secret
+            salt_vault_secret_id: Pangea only allows hashing to be done using a salt value to prevent brute-force attacks.
+            fpe_vault_secret_id: The ID of the key used by FF3 Encryption algorithms for FPE.
+        """
+
+    async def create_service_config(
+        self,
+        name: str,
+        *,
+        version: Literal["1.0.0", "2.0.0"] | None = None,
+        enabled_rules: Sequence[str] | None = None,
+        enforce_enabled_rules: bool | None = None,
+        fpe_vault_secret_id: str | None = None,
+        redactions: Mapping[str, m.Redaction] | None = None,
+        rules: Mapping[str, m.RuleV1 | m.RuleV2] | None = None,
+        rulesets: Mapping[str, m.RulesetV1 | m.RulesetV2] | None = None,
+        salt_vault_secret_id: str | None = None,
+        supported_languages: Sequence[Literal["en"]] | None = None,
+        vault_service_config_id: str | None = None,
+    ) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Create a service config.
+
+        OperationId: redact_post_v1beta_config_create
+
+        Args:
+            enforce_enabled_rules: Always run service config enabled rules across all redact calls regardless of flags?
+            fpe_vault_secret_id: The ID of the key used by FF3 Encryption algorithms for FPE.
+            salt_vault_secret_id: Pangea only allows hashing to be done using a salt value to prevent brute-force attacks.
+            vault_service_config_id: Service config used to create the secret
+        """
+
+        response = await self.request.post(
+            "v1beta/config/create",
+            PangeaResponseResult,
+            data={
+                "name": name,
+                "version": version,
+                "enabled_rules": enabled_rules,
+                "enforce_enabled_rules": enforce_enabled_rules,
+                "fpe_vault_secret_id": fpe_vault_secret_id,
+                "redactions": redactions,
+                "rules": rules,
+                "rulesets": rulesets,
+                "salt_vault_secret_id": salt_vault_secret_id,
+                "supported_languages": supported_languages,
+                "vault_service_config_id": vault_service_config_id,
+            },
+        )
+        response.result = TypeAdapter(m.ServiceConfigResult).validate_python(response.json["result"])
+        return cast(PangeaResponse[m.ServiceConfigResult], response)
+
+    @overload
+    async def update_service_config(
+        self,
+        config_id: str,
+        *,
+        version: Literal["1.0.0"],
+        name: str,
+        updated_at: str,
+        enabled_rules: Sequence[str] | None = None,
+        redactions: Mapping[str, m.Redaction] | None = None,
+        vault_service_config_id: str | None = None,
+        salt_vault_secret_id: str | None = None,
+        rules: Mapping[str, m.RuleV1] | None = None,
+        rulesets: Mapping[str, m.RulesetV1] | None = None,
+        supported_languages: Sequence[Literal["en"]] | None = None,
+    ) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Update a v1.0.0 service config.
+
+        OperationId: redact_post_v1beta_config_update
+
+        Args:
+            vault_service_config_id: Service config used to create the secret
+            salt_vault_secret_id: Pangea only allows hashing to be done using a salt value to prevent brute-force attacks.
+        """
+
+    @overload
+    async def update_service_config(
+        self,
+        config_id: str,
+        *,
+        version: Literal["2.0.0"] | None = None,
+        name: str,
+        updated_at: str,
+        enabled_rules: Sequence[str] | None = None,
+        enforce_enabled_rules: bool | None = None,
+        redactions: Mapping[str, m.Redaction] | None = None,
+        vault_service_config_id: str | None = None,
+        salt_vault_secret_id: str | None = None,
+        fpe_vault_secret_id: str | None = None,
+        rules: Mapping[str, m.RuleV2] | None = None,
+        rulesets: Mapping[str, m.RulesetV2] | None = None,
+        supported_languages: Sequence[Literal["en"]] | None = None,
+    ) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Update a v2.0.0 service config.
+
+        OperationId: redact_post_v1beta_config_update
+
+        Args:
+            enforce_enabled_rules: Always run service config enabled rules across all redact calls regardless of flags?
+            vault_service_config_id: Service config used to create the secret
+            salt_vault_secret_id: Pangea only allows hashing to be done using a salt value to prevent brute-force attacks.
+            fpe_vault_secret_id: The ID of the key used by FF3 Encryption algorithms for FPE.
+        """
+
+    async def update_service_config(
+        self,
+        config_id: str,
+        *,
+        version: Literal["1.0.0", "2.0.0"] | None = None,
+        name: str,
+        updated_at: str,
+        enabled_rules: Sequence[str] | None = None,
+        enforce_enabled_rules: bool | None = None,
+        fpe_vault_secret_id: str | None = None,
+        redactions: Mapping[str, m.Redaction] | None = None,
+        rules: Mapping[str, m.RuleV1 | m.RuleV2] | None = None,
+        rulesets: Mapping[str, m.RulesetV1 | m.RulesetV2] | None = None,
+        salt_vault_secret_id: str | None = None,
+        supported_languages: Sequence[Literal["en"]] | None = None,
+        vault_service_config_id: str | None = None,
+    ) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Update a service config.
+
+        OperationId: redact_post_v1beta_config_update
+
+        Args:
+            enforce_enabled_rules: Always run service config enabled rules across all redact calls regardless of flags?
+            fpe_vault_secret_id: The ID of the key used by FF3 Encryption algorithms for FPE.
+            salt_vault_secret_id: Pangea only allows hashing to be done using a salt value to prevent brute-force attacks.
+            vault_service_config_id: Service config used to create the secret
+        """
+
+        response = await self.request.post(
+            "v1beta/config/update",
+            PangeaResponseResult,
+            data={
+                "id": config_id,
+                "updated_at": updated_at,
+                "name": name,
+                "version": version,
+                "enabled_rules": enabled_rules,
+                "enforce_enabled_rules": enforce_enabled_rules,
+                "fpe_vault_secret_id": fpe_vault_secret_id,
+                "redactions": redactions,
+                "rules": rules,
+                "rulesets": rulesets,
+                "salt_vault_secret_id": salt_vault_secret_id,
+                "supported_languages": supported_languages,
+                "vault_service_config_id": vault_service_config_id,
+            },
+        )
+        response.result = TypeAdapter(m.ServiceConfigResult).validate_python(response.json["result"])
+        return cast(PangeaResponse[m.ServiceConfigResult], response)
+
+    async def delete_service_config(self, config_id: str) -> PangeaResponse[m.ServiceConfigResult]:
+        """
+        Delete a service config.
+
+        OperationId: redact_post_v1beta_config_delete
+
+        Args:
+            config_id: An ID for a service config
+        """
+
+        response = await self.request.post("v1beta/config/delete", PangeaResponseResult, data={"id": config_id})
+        response.result = TypeAdapter(m.ServiceConfigResult).validate_python(response.json["result"])
+        return cast(PangeaResponse[m.ServiceConfigResult], response)
+
+    async def list_service_configs(
+        self,
+        *,
+        filter: m.ServiceConfigFilter | None = None,
+        last: str | None = None,
+        order: Literal["asc", "desc"] | None = None,
+        order_by: Literal["id", "created_at", "updated_at"] | None = None,
+        size: int | None = None,
+    ) -> PangeaResponse[m.ServiceConfigListResult]:
+        """
+        List service configs.
+
+        OperationId: redact_post_v1beta_config_list
+
+        Args:
+            last: Reflected value from a previous response to obtain the next page of results.
+            order: Order results asc(ending) or desc(ending).
+            order_by: Which field to order results by.
+            size: Maximum results to include in the response.
+        """
+
+        return await self.request.post(
+            "v1beta/config/list",
+            m.ServiceConfigListResult,
+            data={"filter": filter, "last": last, "order": order, "order_by": order_by, "size": size},
+        )

pangea/request.py

@@ -11,14 +11,14 @@ import json
 import logging
 import time
 from collections.abc import Iterable, Mapping
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, Union, cast, overload
 
 import requests
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter
 from pydantic_core import to_jsonable_python
 from requests.adapters import HTTPAdapter, Retry
 from requests_toolbelt import MultipartDecoder  # type: ignore[import-untyped]
-from typing_extensions import TypeAlias, TypeVar, override
+from typing_extensions import Literal, TypeAlias, TypeVar, override
 from yarl import URL
 
 import pangea
@@ -220,6 +220,24 @@ class PangeaRequest(PangeaRequestBase):
     def __del__(self) -> None:
         self.session.close()
 
+    def delete(self, endpoint: str) -> None:
+        """
+        Makes a DELETE call to a Pangea endpoint.
+
+        Args:
+            endpoint: The Pangea API endpoint.
+        """
+
+        url = self._url(endpoint)
+
+        self.logger.debug(
+            json.dumps({"service": self.service, "action": "delete", "url": url}, default=default_encoder)
+        )
+
+        requests_response = self._http_delete(url, headers=self._headers())
+        self._check_http_errors(requests_response)
+
+    @overload
     def post(
         self,
         endpoint: str,
@@ -228,18 +246,62 @@ class PangeaRequest(PangeaRequestBase):
         files: Optional[list[Tuple]] = None,
         poll_result: bool = True,
         url: Optional[str] = None,
+        *,
+        pangea_response: Literal[True] = True,
     ) -> PangeaResponse[TResult]:
-        """Makes the POST call to a Pangea Service endpoint.
+        """
+        Makes the POST call to a Pangea Service endpoint.
 
         Args:
-            endpoint(str): The Pangea Service API endpoint.
-            data(dict): The POST body payload object
+            endpoint: The Pangea Service API endpoint.
+            data: The POST body payload object
 
         Returns:
             PangeaResponse which contains the response in its entirety and
                various properties to retrieve individual fields
         """
 
+    @overload
+    def post(
+        self,
+        endpoint: str,
+        result_class: Type[TResult],
+        data: str | BaseModel | Mapping[str, Any] | None = None,
+        files: Optional[list[Tuple]] = None,
+        poll_result: bool = True,
+        url: Optional[str] = None,
+        *,
+        pangea_response: Literal[False],
+    ) -> TResult:
+        """
+        Makes the POST call to a Pangea Service endpoint.
+
+        Args:
+            endpoint: The Pangea Service API endpoint.
+            data: The POST body payload object
+        """
+
+    def post(
+        self,
+        endpoint: str,
+        result_class: Type[TResult],
+        data: str | BaseModel | Mapping[str, Any] | None = None,
+        files: Optional[list[Tuple]] = None,
+        poll_result: bool = True,
+        url: Optional[str] = None,
+        *,
+        pangea_response: bool = True,
+    ) -> PangeaResponse[TResult] | TResult:
+        """
+        Makes a POST call to a Pangea Service endpoint.
+
+        Args:
+            endpoint: The Pangea Service API endpoint.
+            data: The POST body payload object
+            pangea_response: Whether or not the response body follows Pangea's
+              standard response schema
+        """
+
         if isinstance(data, BaseModel):
             data = data.model_dump(exclude_none=True)
 
@@ -277,9 +339,13 @@ class PangeaRequest(PangeaRequestBase):
 
         self._check_http_errors(requests_response)
 
+        if not pangea_response:
+            type_adapter = TypeAdapter(result_class)
+            return type_adapter.validate_python(requests_response.json())
+
         if "multipart/form-data" in requests_response.headers.get("content-type", ""):
             multipart_response = self._process_multipart_response(requests_response)
-            pangea_response: PangeaResponse = PangeaResponse(
+            pangea_response_obj: PangeaResponse = PangeaResponse(
                 requests_response,
                 result_class=result_class,
                 json=multipart_response.pangea_json,
@@ -292,14 +358,14 @@ class PangeaRequest(PangeaRequestBase):
                     json.dumps({"service": self.service, "action": "post", "url": url, "response": json_resp})
                 )
 
-                pangea_response = PangeaResponse(requests_response, result_class=result_class, json=json_resp)
+                pangea_response_obj = PangeaResponse(requests_response, result_class=result_class, json=json_resp)
             except requests.exceptions.JSONDecodeError as e:
                 raise pe.PangeaException(f"Failed to decode json response. {e}. Body: {requests_response.text}") from e
 
         if poll_result:
-            pangea_response = self._handle_queued_result(pangea_response)
+            pangea_response_obj = self._handle_queued_result(pangea_response_obj)
 
-        return self._check_response(pangea_response)
+        return self._check_response(pangea_response_obj)
 
     def _get_pangea_json(self, decoder: MultipartDecoder) -> Optional[Dict]:
         # Iterate through parts
@@ -342,6 +408,14 @@ class PangeaRequest(PangeaRequestBase):
         if resp.status_code == 503:
             raise pe.ServiceTemporarilyUnavailable(resp.json())
 
+    def _http_delete(
+        self,
+        url: str,
+        *,
+        headers: Mapping[str, str | bytes | None] = {},
+    ) -> requests.Response:
+        return self.session.delete(url, headers=headers)
+
     def _http_post(
         self,
         url: str,
@@ -386,37 +460,98 @@ class PangeaRequest(PangeaRequestBase):
 
         return response
 
-    def get(self, path: str, result_class: Type[TResult], check_response: bool = True) -> PangeaResponse[TResult]:
-        """Makes the GET call to a Pangea Service endpoint.
+    @overload
+    def get(
+        self,
+        path: str,
+        result_class: Type[TResult],
+        check_response: bool = True,
+        *,
+        params: (
+            Mapping[str | bytes | int | float, str | bytes | int | float | Iterable[str | bytes | int | float] | None]
+            | None
+        ) = None,
+        pangea_response: Literal[True] = True,
+    ) -> PangeaResponse[TResult]:
+        """
+        Makes the GET call to a Pangea Service endpoint.
 
         Args:
-            endpoint(str): The Pangea Service API endpoint.
-            path(str): Additional URL path
+            path: Additional URL path
+            params: Dictionary of querystring data to attach to the request
 
         Returns:
             PangeaResponse which contains the response in its entirety and
                various properties to retrieve individual fields
         """
 
+    @overload
+    def get(
+        self,
+        path: str,
+        result_class: Type[TResult],
+        check_response: bool = True,
+        *,
+        params: (
+            Mapping[str | bytes | int | float, str | bytes | int | float | Iterable[str | bytes | int | float] | None]
+            | None
+        ) = None,
+        pangea_response: Literal[False] = False,
+    ) -> TResult:
+        """
+        Makes the GET call to a Pangea Service endpoint.
+
+        Args:
+            path: Additional URL path
+            params: Dictionary of querystring data to attach to the request
+        """
+
+    def get(
+        self,
+        path: str,
+        result_class: Type[TResult],
+        check_response: bool = True,
+        *,
+        params: (
+            Mapping[str | bytes | int | float, str | bytes | int | float | Iterable[str | bytes | int | float] | None]
+            | None
+        ) = None,
+        pangea_response: bool = True,
+    ) -> PangeaResponse[TResult] | TResult:
+        """
+        Makes the GET call to a Pangea Service endpoint.
+
+        Args:
+            path: Additional URL path
+            params: Dictionary of querystring data to attach to the request
+            pangea_response: Whether or not the response body follows Pangea's
+              standard response schema
+        """
+
         url = self._url(path)
         self.logger.debug(json.dumps({"service": self.service, "action": "get", "url": url}))
-        requests_response = self.session.get(url, headers=self._headers())
+        requests_response = self.session.get(url, params=params, headers=self._headers())
         self._check_http_errors(requests_response)
-        pangea_response: PangeaResponse = PangeaResponse(
+
+        if not pangea_response:
+            type_adapter = TypeAdapter(result_class)
+            return type_adapter.validate_python(requests_response.json())
+
+        pangea_response_obj: PangeaResponse = PangeaResponse(
             requests_response, result_class=result_class, json=requests_response.json()
         )
 
         self.logger.debug(
             json.dumps(
-                {"service": self.service, "action": "get", "url": url, "response": pangea_response.json},
+                {"service": self.service, "action": "get", "url": url, "response": pangea_response_obj.json},
                 default=default_encoder,
             )
         )
 
         if check_response is False:
-            return pangea_response
+            return pangea_response_obj
 
-        return self._check_response(pangea_response)
+        return self._check_response(pangea_response_obj)
 
     def download_file(self, url: str, filename: str | None = None) -> AttachedFile:
         """

pangea/services/__init__.py

@@ -7,6 +7,7 @@ from .authz import AuthZ
 from .embargo import Embargo
 from .file_scan import FileScan
 from .intel import DomainIntel, FileIntel, IpIntel, UrlIntel, UserIntel
+from .management import Management
 from .prompt_guard import PromptGuard
 from .redact import Redact
 from .sanitize import Sanitize