splunk-soar-sdk 2.3.7__py3-none-any.whl → 3.1.0__py3-none-any.whl

soar_sdk/params.py

@@ -1,11 +1,14 @@
-from typing import Optional, Union, Any, ClassVar
-from typing_extensions import NotRequired, TypedDict
+from typing import Any, ClassVar
+from typing_extensions import TypedDict
+from typing import NotRequired
 
-from pydantic.fields import Field, Undefined
+from pydantic import Field
+from pydantic_core import PydanticUndefined
 from pydantic.main import BaseModel
 
 from soar_sdk.compat import remove_when_soar_newer_than
 from soar_sdk.meta.datatypes import as_datatype
+from soar_sdk.field_utils import parse_json_schema_extra
 
 remove_when_soar_newer_than(
     "7.0.0", "NotRequired from typing_extensions is in typing in Python 3.11+"
@@ -13,16 +16,16 @@ remove_when_soar_newer_than(
 
 
 def Param(
-    description: Optional[str] = None,
+    description: str | None = None,
     required: bool = True,
     primary: bool = False,
-    default: Optional[Any] = None,  # noqa: ANN401
-    value_list: Optional[list] = None,
-    cef_types: Optional[list] = None,
+    default: Any | None = None,  # noqa: ANN401
+    value_list: list | None = None,
+    cef_types: list | None = None,
     allow_list: bool = False,
     sensitive: bool = False,
-    alias: Optional[str] = None,
-    column_name: Optional[str] = None,
+    alias: str | None = None,
+    column_name: str | None = None,
 ) -> Any:  # noqa: ANN401
     """Representation of a single complex action parameter.
 
@@ -53,20 +56,30 @@ def Param(
     :param column_name: Optional name for the parameter when displayed in an output table.
     :return: returns the FieldInfo object as pydantic.Field
     """
-    if value_list is None:
-        value_list = []
+    json_schema_extra: dict[str, Any] = {}
+    if required is not None:
+        json_schema_extra["required"] = required
+    if primary is not None:
+        json_schema_extra["primary"] = primary
+    if value_list:
+        json_schema_extra["value_list"] = value_list
+    if cef_types is not None:
+        json_schema_extra["cef_types"] = cef_types
+    if allow_list is not None:
+        json_schema_extra["allow_list"] = allow_list
+    if sensitive is not None:
+        json_schema_extra["sensitive"] = sensitive
+    if column_name is not None:
+        json_schema_extra["column_name"] = column_name
+
+    # Use ... for required fields
+    field_default: Any = ... if default is None and required else default
 
     return Field(
-        default=default,
+        default=field_default,
         description=description,
-        required=required,
-        primary=primary,
-        value_list=value_list,
-        cef_types=cef_types,
-        allow_list=allow_list,
-        sensitive=sensitive,
         alias=alias,
-        column_name=column_name,
+        json_schema_extra=json_schema_extra if json_schema_extra else None,
     )
 
 
@@ -82,7 +95,7 @@ class InputFieldSpecification(TypedDict):
     primary: bool
     value_list: NotRequired[list[str]]
     allow_list: bool
-    default: NotRequired[Union[str, int, float, bool]]
+    default: NotRequired[str | int | float | bool]
     column_name: NotRequired[str]
     column_order: NotRequired[int]
 
@@ -103,9 +116,12 @@ class Params(BaseModel):
     def _to_json_schema(cls) -> dict[str, InputFieldSpecification]:
         params: dict[str, InputFieldSpecification] = {}
 
-        for field_order, (field_name, field) in enumerate(cls.__fields__.items()):
+        for field_order, (field_name, field) in enumerate(cls.model_fields.items()):
             field_type = field.annotation
 
+            if field_type is None:
+                raise TypeError(f"Parameter {field_name} has no type annotation")
+
             try:
                 type_name = as_datatype(field_type)
             except TypeError as e:
@@ -113,14 +129,16 @@ class Params(BaseModel):
                     f"Failed to serialize action parameter {field_name}: {e}"
                 ) from None
 
-            if field.field_info.extra.get("sensitive", False):
+            json_schema_extra = parse_json_schema_extra(field.json_schema_extra)
+
+            if json_schema_extra.get("sensitive", False):
                 if field_type is not str:
                     raise TypeError(
                         f"Sensitive parameter {field_name} must be type str, not {field_type.__name__}"
                     )
                 type_name = "password"
 
-            if not (description := field.field_info.description):
+            if not (description := field.description):
                 description = cls._default_field_description(field_name)
 
             params_field = InputFieldSpecification(
@@ -128,19 +146,19 @@ class Params(BaseModel):
                 name=field_name,
                 description=description,
                 data_type=type_name,
-                required=field.field_info.extra.get("required", True),
-                primary=field.field_info.extra.get("primary", False),
-                allow_list=field.field_info.extra.get("allow_list", False),
+                required=bool(json_schema_extra.get("required", True)),
+                primary=bool(json_schema_extra.get("primary", False)),
+                allow_list=bool(json_schema_extra.get("allow_list", False)),
             )
 
-            if cef_types := field.field_info.extra.get("cef_types"):
+            if cef_types := json_schema_extra.get("cef_types"):
                 params_field["contains"] = cef_types
-            if (default := field.field_info.default) and default != Undefined:
+            if (default := field.default) not in (PydanticUndefined, None):
                 params_field["default"] = default
-            if value_list := field.field_info.extra.get("value_list"):
+            if value_list := json_schema_extra.get("value_list"):
                 params_field["value_list"] = value_list
 
-            params[field.alias] = params_field
+            params[field.alias or field_name] = params_field
 
         return params
 
@@ -189,21 +207,21 @@ class MakeRequestParams(Params):
         "verify_ssl",
     }
 
-    def __init_subclass__(cls, **kwargs: dict[str, Any]) -> None:
+    def __init_subclass__(cls, **kwargs: Any) -> None:  # noqa: ANN401
         """Validate that subclasses only define allowed fields."""
         super().__init_subclass__(**kwargs)
-        cls._validate_make_request_fields()
 
-    @classmethod
-    def _validate_make_request_fields(cls) -> None:
-        """Ensure subclasses only define allowed MakeRequest fields."""
+    def model_post_init(self, __context: Any) -> None:  # noqa: ANN401
+        """Ensure model fields are validated after instance is created."""
+        super().model_post_init(__context)
         # Check if any fields are not in the allowed set
-        invalid_fields = set(cls.__fields__.keys()) - cls._ALLOWED_FIELDS
-
+        invalid_fields = (
+            set(self.__class__.model_fields.keys()) - self.__class__._ALLOWED_FIELDS
+        )
         if invalid_fields:
             raise TypeError(
-                f"MakeRequestParams subclass '{cls.__name__}' can only define these fields: "
-                f"{sorted(cls._ALLOWED_FIELDS)}. Invalid fields: {sorted(invalid_fields)}"
+                f"MakeRequestParams subclass '{self.__class__.__name__}' can only define these fields: "
+                f"{sorted(self.__class__._ALLOWED_FIELDS)}. Invalid fields: {sorted(invalid_fields)}"
             )
 
     http_method: str = Param(

soar_sdk/shims/phantom/action_result.py

@@ -5,12 +5,12 @@ try:
 except ImportError:
     _soar_is_available = False
 
-from typing import Any, Optional, Union, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 
 if TYPE_CHECKING or not _soar_is_available:
 
     class ActionResult:  # type: ignore[no-redef]
-        def __init__(self, param: Optional[dict] = None) -> None:
+        def __init__(self, param: dict | None = None) -> None:
             self.status = False
             self.message = ""
             self.summary: dict[str, Any] = {}
@@ -24,9 +24,9 @@ if TYPE_CHECKING or not _soar_is_available:
 
         def set_status(
             self,
-            status_code: Union[bool, int],
+            status_code: bool | int,
             _status_message: str = "",
-            _exception: Optional[Exception] = None,
+            _exception: Exception | None = None,
         ) -> bool:
             self.status = bool(status_code)
             self.message = _status_message

soar_sdk/shims/phantom/base_connector.py

@@ -19,7 +19,7 @@ if TYPE_CHECKING or not _soar_is_available:
     from soar_sdk.shims.phantom.action_result import ActionResult
     from soar_sdk.shims.phantom.connector_result import ConnectorResult
 
-    from typing import Union, Any, Optional
+    from typing import Any
     from contextlib import suppress
 
     class BaseConnector:  # type: ignore[no-redef]
@@ -71,14 +71,14 @@ if TYPE_CHECKING or not _soar_is_available:
         def error_print(
             self,
             _tag: str,
-            _dump_object: Union[str, list, dict, ActionResult, Exception] = "",
+            _dump_object: str | list | dict | ActionResult | Exception = "",
         ) -> None:
             print(_tag, _dump_object)
 
         def debug_print(
             self,
             _tag: str,
-            _dump_object: Union[str, list, dict, ActionResult, Exception] = "",
+            _dump_object: str | list | dict | ActionResult | Exception = "",
         ) -> None:
             print(_tag, _dump_object)
 
@@ -109,12 +109,12 @@ if TYPE_CHECKING or not _soar_is_available:
 
         def save_container(
             self, container: dict, fail_on_duplicate: bool = False
-        ) -> tuple[bool, str, Optional[int]]:
+        ) -> tuple[bool, str, int | None]:
             return True, "Container saved successfully", 1
 
         def save_artifacts(
             self, artifacts: list[dict]
-        ) -> tuple[bool, str, Union[Optional[int], list[int]]]:
+        ) -> tuple[bool, str, int | None | list[int]]:
             return True, "Artifacts saved successfully", [1]
 
         def get_config(self) -> dict:

soar_sdk/shims/phantom/ph_ipc.py

@@ -5,7 +5,7 @@ try:
 except ImportError:
     _soar_is_available = False
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING or not _soar_is_available:
     from soar_sdk.shims.phantom.install_info import get_product_version
@@ -34,12 +34,12 @@ if TYPE_CHECKING or not _soar_is_available:
 
             @staticmethod
             def sendstatus(
-                handle: Optional[int], status: int, message: str, flag: bool
+                handle: int | None, status: int, message: str, flag: bool
             ) -> None:
                 print(message)
 
             @staticmethod
-            def debugprint(handle: Optional[int], message: str, level: int) -> None:
+            def debugprint(handle: int | None, message: str, level: int) -> None:
                 print(message)
 
             @staticmethod

soar_sdk/shims/phantom/vault.py

@@ -1,9 +1,10 @@
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from soar_sdk.abstract import SOARClient
 from abc import abstractmethod
 from soar_sdk.exceptions import SoarAPIError
+from datetime import UTC
 
 
 class VaultBase:
@@ -19,9 +20,9 @@ class VaultBase:
     def create_attachment(
         self,
         container_id: int,
-        file_content: Union[str, bytes],
+        file_content: str | bytes,
         file_name: str,
-        metadata: Optional[dict[str, str]] = None,
+        metadata: dict[str, str] | None = None,
     ) -> str:
         """Creates a vault attachment from file content. This differs from add_attachment because it doesn't require the file to exist locally."""
         pass
@@ -32,7 +33,7 @@ class VaultBase:
         container_id: int,
         file_location: str,
         file_name: str,
-        metadata: Optional[dict[str, str]] = None,
+        metadata: dict[str, str] | None = None,
     ) -> str:
         """Add an attachment to vault. This requires the file to exist locally."""
         pass
@@ -40,9 +41,9 @@ class VaultBase:
     @abstractmethod
     def get_attachment(
         self,
-        vault_id: Optional[str] = None,
-        file_name: Optional[str] = None,
-        container_id: Optional[int] = None,
+        vault_id: str | None = None,
+        file_name: str | None = None,
+        container_id: int | None = None,
         download_file: bool = True,
     ) -> list[dict[str, Any]]:
         """Returns vault attachments based on the provided query parameters."""
@@ -51,9 +52,9 @@ class VaultBase:
     @abstractmethod
     def delete_attachment(
         self,
-        vault_id: Optional[str] = None,
-        file_name: Optional[str] = None,
-        container_id: Optional[int] = None,
+        vault_id: str | None = None,
+        file_name: str | None = None,
+        container_id: int | None = None,
         remove_all: bool = False,
     ) -> list[str]:
         """Deletes vault attachments based on the provided query parameters."""
@@ -79,9 +80,9 @@ if _soar_is_available:
         def create_attachment(
             self,
             container_id: int,
-            file_content: Union[str, bytes],
+            file_content: str | bytes,
             file_name: str,
-            metadata: Optional[dict[str, str]] = None,
+            metadata: dict[str, str] | None = None,
         ) -> str:
             resp_json = Vault.create_attachment(
                 file_content, container_id, file_name, metadata
@@ -96,7 +97,7 @@ if _soar_is_available:
             container_id: int,
             file_location: str,
             file_name: str,
-            metadata: Optional[dict[str, str]] = None,
+            metadata: dict[str, str] | None = None,
         ) -> str:
             resp_json = vault_add(container_id, file_location, file_name, metadata)
             if not resp_json.get("succeeded"):
@@ -106,9 +107,9 @@ if _soar_is_available:
 
         def get_attachment(
             self,
-            vault_id: Optional[str] = None,
-            file_name: Optional[str] = None,
-            container_id: Optional[int] = None,
+            vault_id: str | None = None,
+            file_name: str | None = None,
+            container_id: int | None = None,
             download_file: bool = True,
         ) -> list[dict[str, Any]]:
             success, _, attachment = vault_info(
@@ -120,9 +121,9 @@ if _soar_is_available:
 
         def delete_attachment(
             self,
-            vault_id: Optional[str] = None,
-            file_name: Optional[str] = None,
-            container_id: Optional[int] = None,
+            vault_id: str | None = None,
+            file_name: str | None = None,
+            container_id: int | None = None,
             remove_all: bool = False,
         ) -> list[str]:
             success, message, deleted_file_names = vault_delete(
@@ -143,7 +144,7 @@ else:
     from pathlib import Path
     import secrets
     import random
-    from datetime import datetime, timezone
+    from datetime import datetime
     import hashlib
     from soar_sdk.logging import getLogger
     from soar_sdk.models.vault_attachment import VaultAttachment
@@ -162,9 +163,9 @@ else:
         def create_attachment(
             self,
             container_id: int,
-            file_content: Union[str, bytes],
+            file_content: str | bytes,
             file_name: str,
-            metadata: Optional[dict[str, str]] = None,
+            metadata: dict[str, str] | None = None,
         ) -> str:
             if is_client_authenticated(self.soar_client.client):
                 data = {
@@ -203,7 +204,7 @@ else:
                     container_id=container_id,
                     container="test_container",
                     created_via="upload",
-                    create_time=datetime.now(timezone.utc).isoformat(),
+                    create_time=datetime.now(UTC).isoformat(),
                     user="Phantom User",
                     vault_document=doc_id,
                     vault_id=vault_id,
@@ -224,7 +225,7 @@ else:
             container_id: int,
             file_location: str,
             file_name: str,
-            metadata: Optional[dict[str, str]] = None,
+            metadata: dict[str, str] | None = None,
         ) -> str:
             metadata = metadata or {}
 
@@ -265,7 +266,7 @@ else:
                     container_id=container_id,
                     container="test_container",
                     created_via="upload",
-                    create_time=datetime.now(timezone.utc).isoformat(),
+                    create_time=datetime.now(UTC).isoformat(),
                     user="Phantom User",
                     vault_document=doc_id,
                     vault_id=vault_id,
@@ -283,9 +284,9 @@ else:
 
         def get_attachment(
             self,
-            vault_id: Optional[str] = None,
-            file_name: Optional[str] = None,
-            container_id: Optional[int] = None,
+            vault_id: str | None = None,
+            file_name: str | None = None,
+            container_id: int | None = None,
             download_file: bool = True,
         ) -> list[dict[str, Any]]:
             if not any([vault_id, file_name, container_id]):
@@ -295,7 +296,7 @@ else:
 
             results = []
             if is_client_authenticated(self.soar_client.client):
-                query_params: dict[str, Union[str, int]] = {"pretty": ""}
+                query_params: dict[str, str | int] = {"pretty": ""}
                 if vault_id:
                     query_params["_filter_vault_document__hash"] = (
                         f'"{vault_id.lower()}"'
@@ -319,22 +320,22 @@ else:
                 if vault_id:
                     res = self.__storage.get(vault_id)
                     if res:
-                        results.append(res.dict())
+                        results.append(res.model_dump())
 
                 if any((container_id, file_name)):
                     for _, res in self.__storage.items():
                         if (
                             file_name and file_name in res.file_path
                         ) or container_id == res.container_id:
-                            results.append(res.dict())
+                            results.append(res.model_dump())
 
             return results
 
         def delete_attachment(
             self,
-            vault_id: Optional[str] = None,
-            file_name: Optional[str] = None,
-            container_id: Optional[int] = None,
+            vault_id: str | None = None,
+            file_name: str | None = None,
+            container_id: int | None = None,
             remove_all: bool = False,
         ) -> list[str]:
             vault_enteries = self.get_attachment(vault_id, file_name, container_id)

soar_sdk/types.py

@@ -1,5 +1,6 @@
 import typing
-from typing import Any, Callable, Optional, Protocol
+from typing import Any, Protocol
+from collections.abc import Callable
 
 from soar_sdk.meta.actions import ActionMeta
 from soar_sdk.params import Params
@@ -9,7 +10,7 @@ class Action(Protocol):
     """Type interface for an action definition."""
 
     meta: ActionMeta
-    params_class: Optional[type[Params]] = None
+    params_class: type[Params] | None = None
 
     def __call__(self, *args: Any, **kwargs: Any) -> bool:  # noqa: ANN401
         """Execute the action function."""

soar_sdk/views/template_filters.py

@@ -10,7 +10,7 @@ import uuid
 import humanize
 import bleach  # type: ignore[import-untyped]
 from datetime import datetime, timedelta
-from typing import Optional, TypeVar, Union
+from typing import TypeVar
 from collections.abc import Iterable
 from collections.abc import Iterator
 from jinja2 import Environment
@@ -77,7 +77,7 @@ def by_key(dictionary: dict, key: str) -> str:
     return dictionary.get(key, "")
 
 
-def by_nested_key(dictionary: dict, key: str) -> Optional[str]:
+def by_nested_key(dictionary: dict, key: str) -> str | None:
     """Get nested dictionary value by space-separated key."""
     split_key = key.split()
     src = dictionary.get(split_key[0], None)
@@ -97,7 +97,7 @@ def typeof(item: object) -> type:
     return type(item)
 
 
-def safe_intcomma(value: Union[str, int]) -> str:
+def safe_intcomma(value: str | int) -> str:
     """Format integer with commas, safely handling non-integers."""
     try:
         return f"{int(value):,}"
@@ -143,7 +143,7 @@ def to_json(obj: object) -> str:
     return json.dumps(obj)
 
 
-def absval(obj: Union[int, float]) -> Union[int, float]:
+def absval(obj: int | float) -> int | float:
     """Get absolute value."""
     return abs(obj)
 

soar_sdk/views/template_renderer.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 from jinja2 import Environment, FileSystemLoader, select_autoescape
 from soar_sdk.views.template_filters import setup_jinja_env
 from soar_sdk.paths import SDK_TEMPLATES
@@ -107,7 +107,7 @@ class JinjaTemplateRenderer(TemplateRenderer):
 
 
 def get_template_renderer(
-    engine: Optional[str] = None, templates_dir: Optional[str] = None
+    engine: str | None = None, templates_dir: str | None = None
 ) -> TemplateRenderer:
     """Factory function to get the appropriate template renderer.
 

soar_sdk/views/view_parser.py

@@ -1,13 +1,12 @@
 from typing import (
     Any,
-    Callable,
     TypeVar,
-    Union,
     get_origin,
     get_args,
     Generic,
     cast,
 )
+from collections.abc import Callable
 import inspect
 from pydantic import BaseModel
 from soar_sdk.action_results import ActionOutput
@@ -68,7 +67,7 @@ class ViewFunctionParser(Generic[T]):
             for result in action_results:
                 for data_item in result.get_data():
                     try:
-                        parsed_output = self.output_class.parse_obj(data_item)
+                        parsed_output = self.output_class.model_validate(data_item)
                         parsed_outputs.append(parsed_output)
                     except Exception as e:
                         output_class_name = self.output_class.__name__
@@ -85,7 +84,7 @@ class ViewFunctionParser(Generic[T]):
         context: ViewContext,
         *args: Any,  # noqa: ANN401
         **kwargs: Any,  # noqa: ANN401
-    ) -> Union[str, dict, BaseModel]:
+    ) -> str | dict | BaseModel:
         """Wrapper around the object's view function which massages platform inputs as necessary.
 
         Takes the JSON list of AppRun results provided by Splunk SOAR, parses that into

soar_sdk/webhooks/models.py

@@ -2,7 +2,8 @@ import json
 import base64
 import mimetypes
 
-from typing import Optional, TypeVar, Generic, Any, IO, Callable
+from typing import TypeVar, Generic, Any, IO
+from collections.abc import Callable
 from pydantic import BaseModel, Field
 
 from soar_sdk.asset import BaseAsset
@@ -18,7 +19,7 @@ class WebhookRequest(BaseModel, Generic[AssetType]):
     headers: dict[str, str]
     path_parts: list[str]
     query: dict[str, list[str]]
-    body: Optional[str]
+    body: str | None
     asset: AssetType
     soar_base_url: str
     soar_auth_token: str
@@ -65,7 +66,7 @@ class WebhookResponse(BaseModel):
     def text_response(
         content: str,
         status_code: int = 200,
-        extra_headers: Optional[dict[str, Any]] = None,
+        extra_headers: dict[str, Any] | None = None,
     ) -> "WebhookResponse":
         """Build a WebhookResponse object given raw textual content.
 
@@ -83,7 +84,7 @@ class WebhookResponse(BaseModel):
     def json_response(
         content: dict,
         status_code: int = 200,
-        extra_headers: Optional[dict[str, Any]] = None,
+        extra_headers: dict[str, Any] | None = None,
     ) -> "WebhookResponse":
         """Build a WebhookResponse object given a dictionary, to be interpreted as JSON.
 
@@ -101,9 +102,9 @@ class WebhookResponse(BaseModel):
     def file_response(
         fd: IO,
         filename: str,
-        content_type: Optional[str] = None,
+        content_type: str | None = None,
         status_code: int = 200,
-        extra_headers: Optional[dict[str, Any]] = None,
+        extra_headers: dict[str, Any] | None = None,
     ) -> "WebhookResponse":
         """Build a webhook response using the data in a given open file-like object.
 

soar_sdk/webhooks/routing.py

@@ -5,7 +5,8 @@ This module provides a router for mapping URL patterns to handler functions.
 
 import re
 from dataclasses import dataclass
-from typing import Callable, TypeVar, Generic, Optional
+from typing import TypeVar, Generic
+from collections.abc import Callable
 from collections.abc import Sequence
 
 from soar_sdk.webhooks.models import WebhookRequest, WebhookResponse
@@ -45,7 +46,7 @@ class Router(Generic[AssetType]):
         self,
         pattern: str,
         handler: Callable[[WebhookRequest], WebhookResponse],
-        methods: Optional[Sequence[str]] = None,
+        methods: Sequence[str] | None = None,
     ) -> None:
         """Register a new route with the router.
 
@@ -146,7 +147,7 @@ class Router(Generic[AssetType]):
             return False
 
         # Check each segment
-        for part1, part2 in zip(parts1, parts2):
+        for part1, part2 in zip(parts1, parts2, strict=False):
             is_param1 = part1.startswith("<") and part1.endswith(">")
             is_param2 = part2.startswith("<") and part2.endswith(">")