pangea-sdk 6.1.1__py3-none-any.whl → 6.2.0b2__py3-none-any.whl

pangea/asyncio/services/redact.py

@@ -1,13 +1,20 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
+
+# TODO: Modernize.
+# ruff: noqa: UP006, UP035
+
 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):
@@ -64,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]:
@@ -119,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]:
@@ -200,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/asyncio/services/sanitize.py

@@ -1,5 +1,9 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
+
+# TODO: Modernize.
+# ruff: noqa: UP006, UP035
+
 from __future__ import annotations
 
 import io
@@ -116,7 +120,7 @@ class SanitizeAsync(ServiceBaseAsync):
         files: Optional[List[Tuple]] = None
         if file or file_path:
             if file_path:
-                file = open(file_path, "rb")
+                file = open(file_path, "rb")  # noqa: SIM115
             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

pangea/asyncio/services/share.py

@@ -1,5 +1,9 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
+
+# TODO: Modernize.
+# ruff: noqa: UP006, UP035
+
 from __future__ import annotations
 
 import io
@@ -194,7 +198,7 @@ class ShareAsync(ServiceBaseAsync):
 
     async def get_archive(
         self,
-        ids: List[str] = [],
+        ids: list[str],
         format: Optional[m.ArchiveFormat] = None,
         transfer_method: Optional[TransferMethod] = None,
         bucket_id: Optional[str] = None,

pangea/asyncio/services/vault.py

@@ -1,5 +1,9 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
+
+# TODO: Modernize.
+# ruff: noqa: UP006, UP035
+
 from __future__ import annotations
 
 from collections.abc import Mapping

pangea/audit_logger.py

@@ -1,5 +1,7 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
+from __future__ import annotations
+
 import logging
 
 import pangea.exceptions as pe
@@ -20,7 +22,7 @@ class AuditLogger(logging.Logger):
     """
 
     def __init__(self, *args, **kwargs):
-        super(AuditLogger, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
 
     def set_auditor(self, auditor: Audit):
         """Sets the internal Pangea Audit Service client instance

pangea/deep_verify.py

@@ -1,13 +1,16 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
 
+from __future__ import annotations
+
 import argparse
 import io
 import math
 import os
 import sys
+from collections.abc import Iterator
 from itertools import groupby
-from typing import Dict, Iterator, List, Optional, Set, TypedDict, Union
+from typing import Optional, TypedDict, Union
 
 import pangea.services.audit.util as audit_util
 from pangea.services import Audit
@@ -24,7 +27,7 @@ class Errors(TypedDict):
     buffer_missing: int
 
 
-root_hashes: Dict[int, str] = {}
+root_hashes: dict[int, str] = {}
 
 
 def num_lines(f: io.TextIOWrapper) -> int:
@@ -124,10 +127,7 @@ def get_root_hash(audit: Audit, tree_size: int) -> str:
 
 
 def print_error(msg: str, level: str = "error"):
-    if level == "warning":
-        dot = "🟡"
-    else:
-        dot = "🔴"
+    dot = "🟡" if level == "warning" else "🔴"
     print(f"{dot} {msg:200s}")
 
 
@@ -148,14 +148,14 @@ def deep_verify(audit: Audit, file: io.TextIOWrapper) -> Errors:
     }
 
     events = file_events(root_hashes, file)
-    events_by_idx: Union[List[Event], Iterator[Event]]
+    events_by_idx: Union[list[Event], Iterator[Event]]
     cold_indexes = SequenceFollower()
     for leaf_index, events_by_idx in groupby(events, lambda event: event.get("leaf_index")):
         events_by_idx = list(events_by_idx)
         buffer_lines = (cnt, cnt + len(events_by_idx) - 1)
         if leaf_index is None:
             print_error(
-                f"Lines {buffer_lines[0]}-{buffer_lines[1]} ({buffer_lines[1]-buffer_lines[0]+1}): Buffer was not persisted"
+                f"Lines {buffer_lines[0]}-{buffer_lines[1]} ({buffer_lines[1] - buffer_lines[0] + 1}): Buffer was not persisted"
             )
             errors["not_persisted"] += len(events_by_idx)
             cnt += len(events_by_idx)
@@ -164,8 +164,8 @@ def deep_verify(audit: Audit, file: io.TextIOWrapper) -> Errors:
         cold_indexes.add(leaf_index)
 
         cold_path_size: Optional[int] = None
-        hot_indexes: Set[int] = set()
-        for i, event in enumerate(events_by_idx):
+        hot_indexes: set[int] = set()
+        for _i, event in enumerate(events_by_idx):
             cnt += 1
             tree_size = get_tree_size(event)
             if tree_size not in root_hashes:
@@ -203,11 +203,11 @@ def deep_verify(audit: Audit, file: io.TextIOWrapper) -> Errors:
             errors["missing"] += len(hot_indexes_diff)
             print(f"missing hot indexes: {hot_indexes_diff}")
             print(f"hot_indexes: {hot_indexes} ")
-            print(f"events:")
+            print("events:")
             for e in events_by_idx:
                 print(e)
             print_error(
-                f"Lines {buffer_lines[0]}-{buffer_lines[1]} ({buffer_lines[1]-buffer_lines[0]}), Buffer #{cold_idx}: {len(hot_indexes_diff)} event(s) missing"
+                f"Lines {buffer_lines[0]}-{buffer_lines[1]} ({buffer_lines[1] - buffer_lines[0]}), Buffer #{cold_idx}: {len(hot_indexes_diff)} event(s) missing"
             )
 
     cold_holes = cold_indexes.holes()
@@ -232,7 +232,7 @@ def create_parser():
         "-f",
         required=True,
         type=argparse.FileType("r"),
-        help="Event input file. Must be a collection of " "JSON Objects separated by newlines",
+        help="Event input file. Must be a collection of JSON Objects separated by newlines",
     )
     return parser
 

pangea/deprecated.py

@@ -19,7 +19,7 @@ def pangea_deprecated(*args, **kwargs):
         def wrapper(*iargs, **ikwargs):
             return deprecated(*args, **kwargs)(f)(*iargs, **ikwargs)
 
-        setattr(wrapper, "_deprecated", kwargs)
+        wrapper._deprecated = kwargs
         return wrapper
 
     return decorator

pangea/dump_audit.py

@@ -7,7 +7,6 @@ import json
 import os
 import sys
 from datetime import datetime
-from typing import Tuple
 
 import dateutil.parser
 
@@ -103,7 +102,7 @@ def dump_after(audit: Audit, output: io.TextIOWrapper, start: datetime, last_eve
 
 def dump_page(
     audit: Audit, output: io.TextIOWrapper, start: datetime, end: datetime, first: bool = False
-) -> Tuple[datetime, int, bool, str, int]:
+) -> tuple[datetime, int, bool, str, int]:
     PAGE_SIZE = 1000
     print(start, end)
     print("Dumping...")
@@ -175,7 +174,7 @@ def parse_args(parser: argparse.ArgumentParser):
         raise ValueError("domain missing")
 
     if args.output is None:
-        args.output = open(f"dump-{datetime.now().strftime('%Y%m%d%H%M%S')}.jsonl", "w")
+        args.output = open(f"dump-{datetime.now().strftime('%Y%m%d%H%M%S')}.jsonl", "w")  # noqa: SIM115
 
     args.start = make_aware_datetime(args.start)
     args.end = make_aware_datetime(args.end)

pangea/exceptions.py

@@ -1,6 +1,9 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
 
+# TODO: Modernize.
+# ruff: noqa: UP006, UP035
+
 from typing import List, Optional
 
 from pangea.response import AcceptedResult, ErrorField, PangeaResponse
@@ -44,7 +47,7 @@ class PangeaAPIException(PangeaException):
     response: PangeaResponse
 
     def __init__(self, message: str, response: PangeaResponse):
-        super(PangeaAPIException, self).__init__(message)
+        super().__init__(message)
         self.response = response
 
     @property
@@ -92,7 +95,7 @@ class UnauthorizedException(PangeaAPIException):
 
     def __init__(self, service_name: str, response: PangeaResponse):
         message = f"User is not authorized to access service {service_name}"
-        super(UnauthorizedException, self).__init__(message, response)
+        super().__init__(message, response)
 
 
 class NotFound(PangeaAPIException):
@@ -100,20 +103,20 @@ class NotFound(PangeaAPIException):
 
     def __init__(self, url: str, response: PangeaResponse):
         message = f"Resource url:'{url}' not found"
-        super(NotFound, self).__init__(message, response)
+        super().__init__(message, response)
 
 
 class ServiceNotEnabledException(PangeaAPIException):
     def __init__(self, service_name: str, response: PangeaResponse):
         message = f"{service_name} is not enabled. Go to console.pangea.cloud/service/{service_name} to enable"
-        super(ServiceNotEnabledException, self).__init__(message, response)
+        super().__init__(message, response)
 
 
 class MissingConfigID(PangeaAPIException):
     """No config ID was provided in either token scopes or explicitly"""
 
     def __init__(self, service_name: str, response: PangeaResponse):
-        super(MissingConfigID, self).__init__(
+        super().__init__(
             f"Token did not contain a config scope for service {service_name}. Create a new token or provide a config ID explicitly in the service base",
             response,
         )

pangea/file_uploader.py

@@ -1,5 +1,9 @@
 # Copyright 2022 Pangea Cyber Corporation
 # Author: Pangea Cyber Corporation
+
+# TODO: Modernize.
+# ruff: noqa: UP006, UP035
+
 import io
 import logging
 from typing import Dict, Optional