pangea-sdk 6.0.0__py3-none-any.whl → 6.2.0b1__py3-none-any.whl

pangea/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "6.0.0"
+__version__ = "6.2.0beta1"
 
 from pangea.asyncio.request import PangeaRequestAsync
 from pangea.config import PangeaConfig

pangea/asyncio/request.py

@@ -5,11 +5,12 @@ from __future__ import annotations
 import asyncio
 import json
 import time
-from typing import Dict, List, Optional, Sequence, Tuple, Type, Union, cast
+from collections.abc import Iterable, Mapping
+from typing import Dict, List, Literal, Optional, Sequence, Tuple, Type, Union, cast, overload
 
 import aiohttp
 from aiohttp import FormData
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter
 from pydantic_core import to_jsonable_python
 from typing_extensions import Any, TypeVar
 
@@ -30,6 +31,24 @@ class PangeaRequestAsync(PangeaRequestBase):
     be set in PangeaConfig.
     """
 
+    async 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 = await self._http_delete(url, headers=self._headers())
+        await self._check_http_errors(requests_response)
+
+    @overload
     async def post(
         self,
         endpoint: str,
@@ -38,18 +57,60 @@ class PangeaRequestAsync(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 a 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
+    async def post(
+        self,
+        endpoint: str,
+        result_class: Type[TResult],
+        data: str | BaseModel | dict[str, Any] | None = None,
+        files: Optional[List[Tuple]] = None,
+        poll_result: bool = True,
+        url: Optional[str] = None,
+        *,
+        pangea_response: Literal[False],
+    ) -> TResult:
+        """
+        Makes a POST call to a Pangea Service endpoint.
+
+        Args:
+            endpoint: The Pangea Service API endpoint.
+            data: The POST body payload object
+        """
+
+    async def post(
+        self,
+        endpoint: str,
+        result_class: Type[TResult],
+        data: str | BaseModel | dict[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
+        """
+
         if isinstance(data, BaseModel):
             data = data.model_dump(exclude_none=True)
 
@@ -86,9 +147,13 @@ class PangeaRequestAsync(PangeaRequestBase):
 
         await self._check_http_errors(requests_response)
 
+        if not pangea_response:
+            type_adapter = TypeAdapter(result_class)
+            return type_adapter.validate_python(await requests_response.json())
+
         if "multipart/form-data" in requests_response.headers.get("content-type", ""):
             multipart_response = await 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,
@@ -101,47 +166,108 @@ class PangeaRequestAsync(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 aiohttp.ContentTypeError as e:
                 raise pe.PangeaException(f"Failed to decode json response. {e}. Body: {await requests_response.text()}")
 
         if poll_result:
-            pangea_response = await self._handle_queued_result(pangea_response)
+            pangea_response_obj = await self._handle_queued_result(pangea_response_obj)
 
-        return self._check_response(pangea_response)
+        return self._check_response(pangea_response_obj)
 
-    async 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
+    async 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
+    async 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
+        """
+
+    async 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}))
 
-        async with self.session.get(url, headers=self._headers()) as requests_response:
+        async with self.session.get(url, params=params, headers=self._headers()) as requests_response:
             await self._check_http_errors(requests_response)
-            pangea_response = PangeaResponse(
+
+            if not pangea_response:
+                type_adapter = TypeAdapter(result_class)
+                return type_adapter.validate_python(await requests_response.json())
+
+            pangea_response_obj = PangeaResponse(
                 requests_response, result_class=result_class, json=await 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)
 
     async def _check_http_errors(self, resp: aiohttp.ClientResponse):
         if resp.status == 503:
@@ -275,10 +401,18 @@ class PangeaRequestAsync(PangeaRequestBase):
         attached_files = await self._get_attached_files(multipart_reader)
         return MultipartResponse(pangea_json, attached_files)  # type: ignore[arg-type]
 
+    async def _http_delete(
+        self,
+        url: str,
+        *,
+        headers: Mapping[str, str | bytes | None] = {},
+    ) -> aiohttp.ClientResponse:
+        return await self.session.delete(url, headers=headers)
+
     async def _http_post(
         self,
         url: str,
-        headers: Dict = {},
+        headers: Mapping[str, str | bytes | None] = {},
         data: Union[str, Dict] = {},
         files: Optional[List[Tuple]] = [],
         presigned_url_post: bool = False,

pangea/asyncio/services/__init__.py

@@ -5,6 +5,7 @@ from .authz import AuthZAsync
 from .embargo import EmbargoAsync
 from .file_scan import FileScanAsync
 from .intel import DomainIntelAsync, FileIntelAsync, IpIntelAsync, UrlIntelAsync, UserIntelAsync
+from .management import ManagementAsync
 from .prompt_guard import PromptGuardAsync
 from .redact import RedactAsync
 from .sanitize import SanitizeAsync

pangea/asyncio/services/audit.py

@@ -3,7 +3,9 @@
 from __future__ import annotations
 
 import datetime
-from typing import Any, Dict, Iterable, List, Optional, Sequence, Union
+from typing import Any, Dict, Iterable, List, Literal, Optional, Sequence, Union, cast, overload
+
+from pydantic import TypeAdapter
 
 import pangea.exceptions as pexc
 from pangea.asyncio.services.base import ServiceBaseAsync
@@ -12,11 +14,13 @@ from pangea.response import PangeaResponse, PangeaResponseResult
 from pangea.services.audit.audit import AuditBase
 from pangea.services.audit.exceptions import AuditException
 from pangea.services.audit.models import (
+    AuditSchema,
     DownloadFormat,
     DownloadRequest,
     DownloadResult,
     Event,
     ExportRequest,
+    ForwardingConfiguration,
     LogBulkResult,
     LogResult,
     PublishedRoot,
@@ -29,6 +33,9 @@ from pangea.services.audit.models import (
     SearchRequest,
     SearchResultOutput,
     SearchResultRequest,
+    ServiceConfig,
+    ServiceConfigFilter,
+    ServiceConfigListResult,
 )
 from pangea.services.audit.util import format_datetime
 
@@ -590,6 +597,298 @@ class AuditAsync(ServiceBaseAsync, AuditBase):
         )
         return await self.request.post("v1/download_results", DownloadResult, data=input.model_dump(exclude_none=True))
 
+    async def get_service_config(self, config_id: str) -> PangeaResponse[ServiceConfig]:
+        """
+        Get a service config.
+
+        OperationId: audit_post_v1beta_config
+
+        Args:
+            id: The config ID
+        """
+
+        response = await self.request.post("v1beta/config", PangeaResponseResult, data={"id": config_id})
+        response.result = TypeAdapter(ServiceConfig).validate_python(response.json["result"])
+        return cast(PangeaResponse[ServiceConfig], response)
+
+    @overload
+    async def create_service_config(
+        self,
+        version: Literal[1],
+        name: str,
+        *,
+        cold_query_result_retention: str | None = None,
+        hot_storage: str | None = None,
+        query_result_retention: str | None = None,
+        redact_service_config_id: str | None = None,
+        redaction_fields: Sequence[str] | None = None,
+        retention: str | None = None,
+        vault_key_id: str | None = None,
+        vault_service_config_id: str | None = None,
+        vault_sign: bool | None = None,
+    ) -> PangeaResponse[ServiceConfig]:
+        """
+        Create a v1 service config.
+
+        OperationId: audit_post_v1beta_config_create
+
+        Args:
+            name: Configuration name
+            cold_query_result_retention: Retention window for cold query result / state information.
+            hot_storage: Retention window to keep audit logs in hot storage.
+            query_result_retention: Length of time to preserve server-side query result caching.
+            redact_service_config_id: A redact service config that will be used to redact PII from logs.
+            redaction_fields: Fields to perform redaction against.
+            retention: Retention window to store audit logs.
+            vault_key_id: ID of the Vault key used for signing. If missing, use a default Audit key.
+            vault_service_config_id: A vault service config that will be used to sign logs.
+            vault_sign: Enable/disable event signing.
+        """
+
+    @overload
+    async def create_service_config(
+        self,
+        version: Literal[2],
+        name: str,
+        *,
+        schema: AuditSchema,
+        cold_query_result_retention: str | None = None,
+        forwarding_configuration: ForwardingConfiguration | None = None,
+        hot_storage: str | None = None,
+        query_result_retention: str | None = None,
+        redact_service_config_id: str | None = None,
+        retention: str | None = None,
+        vault_key_id: str | None = None,
+        vault_service_config_id: str | None = None,
+        vault_sign: bool | None = None,
+    ) -> PangeaResponse[ServiceConfig]:
+        """
+        Create a v2 service config.
+
+        OperationId: audit_post_v1beta_config_create
+
+        Args:
+            name: Configuration name
+            schema: Audit log field configuration. Only settable at create time.
+            cold_query_result_retention: Retention window for cold query result / state information.
+            forwarding_configuration: Configuration for forwarding audit logs to external systems.
+            hot_storage: Retention window to keep audit logs in hot storage.
+            query_result_retention: Length of time to preserve server-side query result caching.
+            redact_service_config_id: A redact service config that will be used to redact PII from logs.
+            retention: Retention window to store audit logs.
+            vault_key_id: ID of the Vault key used for signing. If missing, use a default Audit key.
+            vault_service_config_id: A vault service config that will be used to sign logs.
+            vault_sign: Enable/disable event signing.
+        """
+
+    @overload
+    async def create_service_config(
+        self,
+        version: Literal[3],
+        name: str,
+        *,
+        schema: AuditSchema,
+        cold_storage: str | None = None,
+        hot_storage: str | None = None,
+        warm_storage: str | None = None,
+        redact_service_config_id: str | None = None,
+        vault_service_config_id: str | None = None,
+        vault_key_id: str | None = None,
+        vault_sign: bool | None = None,
+        forwarding_configuration: ForwardingConfiguration | None = None,
+    ) -> PangeaResponse[ServiceConfig]:
+        """
+        Create a v3 service config.
+
+        OperationId: audit_post_v1beta_config_create
+
+        Args:
+            name: Configuration name
+            schema: Audit log field configuration. Only settable at create time.
+            cold_storage: Retention window for logs in cold storage. Deleted afterwards.
+            hot_storage: Retention window for logs in hot storage. Migrated to warm, cold, or deleted afterwards.
+            warm_storage: Retention window for logs in warm storage. Migrated to cold or deleted afterwards.
+            redact_service_config_id: A redact service config that will be used to redact PII from logs.
+            vault_service_config_id: A vault service config that will be used to sign logs.
+            vault_key_id: ID of the Vault key used for signing. If missing, use a default Audit key.
+            vault_sign: Enable/disable event signing.
+            forwarding_configuration: Configuration for forwarding audit logs to external systems.
+        """
+
+    async def create_service_config(
+        self,
+        version: Literal[1, 2, 3],
+        name: str,
+        *,
+        cold_query_result_retention: str | None = None,
+        cold_storage: str | None = None,
+        forwarding_configuration: ForwardingConfiguration | None = None,
+        hot_storage: str | None = None,
+        query_result_retention: str | None = None,
+        redact_service_config_id: str | None = None,
+        redaction_fields: Sequence[str] | None = None,
+        retention: str | None = None,
+        schema: AuditSchema | None = None,
+        vault_key_id: str | None = None,
+        vault_service_config_id: str | None = None,
+        vault_sign: bool | None = None,
+        warm_storage: str | None = None,
+    ) -> PangeaResponse[ServiceConfig]:
+        """
+        Create a service config.
+
+        OperationId: audit_post_v1beta_config_create
+
+        Args:
+            name: Configuration name
+            cold_query_result_retention: Retention window for cold query result / state information.
+            cold_storage: Retention window for logs in cold storage. Deleted afterwards.
+            forwarding_configuration: Configuration for forwarding audit logs to external systems.
+            hot_storage: Retention window to keep audit logs in hot storage.
+            query_result_retention: Length of time to preserve server-side query result caching.
+            redact_service_config_id: A redact service config that will be used to redact PII from logs.
+            redaction_fields: Fields to perform redaction against.
+            retention: Retention window to store audit logs.
+            schema: Audit log field configuration. Only settable at create time.
+            vault_key_id: ID of the Vault key used for signing. If missing, use a default Audit key.
+            vault_service_config_id: A vault service config that will be used to sign logs.
+            vault_sign: Enable/disable event signing.
+            warm_storage: Retention window for logs in warm storage. Migrated to cold or deleted afterwards.
+        """
+
+        response = await self.request.post(
+            "v1beta/config/create",
+            PangeaResponseResult,
+            data={
+                "cold_query_result_retention": cold_query_result_retention,
+                "cold_storage": cold_storage,
+                "forwarding_configuration": forwarding_configuration,
+                "hot_storage": hot_storage,
+                "name": name,
+                "query_result_retention": query_result_retention,
+                "redact_service_config_id": redact_service_config_id,
+                "redaction_fields": redaction_fields,
+                "retention": retention,
+                "schema": schema,
+                "vault_key_id": vault_key_id,
+                "vault_service_config_id": vault_service_config_id,
+                "vault_sign": vault_sign,
+                "warm_storage": warm_storage,
+                "version": version,
+            },
+        )
+        response.result = TypeAdapter(ServiceConfig).validate_python(response.json["result"])
+        return cast(PangeaResponse[ServiceConfig], response)
+
+    async def update_service_config(
+        self,
+        config_id: str,
+        *,
+        name: str,
+        updated_at: datetime.datetime,
+        # Optionals.
+        cold_query_result_retention: str | None = None,
+        cold_storage: str | None = None,
+        forwarding_configuration: ForwardingConfiguration | None = None,
+        hot_storage: str | None = None,
+        query_result_retention: str | None = None,
+        redact_service_config_id: str | None = None,
+        retention: str | None = None,
+        schema: AuditSchema | None = None,
+        vault_key_id: str | None = None,
+        vault_service_config_id: str | None = None,
+        vault_sign: bool | None = None,
+        warm_storage: str | None = None,
+    ) -> PangeaResponse[ServiceConfig]:
+        """
+        Update a service config.
+
+        OperationId: audit_post_v1beta_config_update
+
+        Args:
+            id: The config ID
+            name: Configuration name
+            updated_at: The DB timestamp when this config was last updated at
+            cold_query_result_retention: Retention window for cold query result / state information.
+            cold_storage: Retention window for logs in cold storage. Deleted afterwards.
+            forwarding_configuration: Configuration for forwarding audit logs to external systems
+            hot_storage: Retention window to keep audit logs in hot storage
+            query_result_retention: Length of time to preserve server-side query result caching
+            redact_service_config_id: A redact service config that will be used to redact PII from logs
+            retention: Retention window to store audit logs
+            schema: Audit log field configuration
+            vault_key_id: ID of the Vault key used for signing. If missing, use a default Audit key.
+            vault_service_config_id: A vault service config that will be used to sign logs
+            vault_sign: Enable/disable event signing
+            warm_storage: Retention window for logs in warm storage. Migrated to cold or deleted afterwards.
+        """
+
+        response = await self.request.post(
+            "v1beta/config/update",
+            PangeaResponseResult,
+            data={
+                "id": config_id,
+                "name": name,
+                "updated_at": updated_at,
+                # Optionals.
+                "cold_query_result_retention": cold_query_result_retention,
+                "cold_storage": cold_storage,
+                "forwarding_configuration": forwarding_configuration,
+                "hot_storage": hot_storage,
+                "query_result_retention": query_result_retention,
+                "redact_service_config_id": redact_service_config_id,
+                "retention": retention,
+                "schema": schema,
+                "vault_key_id": vault_key_id,
+                "vault_service_config_id": vault_service_config_id,
+                "vault_sign": vault_sign,
+                "warm_storage": warm_storage,
+            },
+        )
+        response.result = TypeAdapter(ServiceConfig).validate_python(response.json["result"])
+        return cast(PangeaResponse[ServiceConfig], response)
+
+    async def delete_service_config(self, config_id: str) -> PangeaResponse[ServiceConfig]:
+        """
+        Delete a service config.
+
+        OperationId: audit_post_v1beta_config_delete
+
+        Args:
+            id: The config ID
+        """
+
+        response = await self.request.post("v1beta/config/delete", PangeaResponseResult, data={"id": config_id})
+        response.result = TypeAdapter(ServiceConfig).validate_python(response.json["result"])
+        return cast(PangeaResponse[ServiceConfig], response)
+
+    async def list_service_configs(
+        self,
+        *,
+        filter: 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[ServiceConfigListResult]:
+        """
+        List service configs.
+
+        OperationId: audit_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",
+            ServiceConfigListResult,
+            data={"filter": filter, "last": last, "order": order, "order_by": order_by, "size": size},
+        )
+
     async def update_published_roots(self, result: SearchResultOutput):
         """Fetches series of published root hashes from Arweave