splunk-soar-sdk 2.3.6__py3-none-any.whl → 3.0.0__py3-none-any.whl

soar_sdk/app.py

@@ -3,7 +3,8 @@ import inspect
 import json
 from pathlib import Path
 import sys
-from typing import Any, Optional, Union, Callable
+from typing import Any
+from collections.abc import Callable
 from collections.abc import Iterator
 from zoneinfo import ZoneInfo
 
@@ -101,7 +102,7 @@ class App:
         product_name: str,
         publisher: str,
         appid: str,
-        python_version: Optional[Union[list[PythonVersion], str]] = None,
+        python_version: list[PythonVersion] | str | None = None,
         min_phantom_version: str = MIN_PHANTOM_VERSION,
         fips_compliant: bool = False,
         asset_cls: type[BaseAsset] = BaseAsset,
@@ -164,13 +165,13 @@ class App:
         runner = AppCliRunner(self)
         runner.run()
 
-    def handle(self, raw_input_data: str, handle: Optional[int] = None) -> str:
+    def handle(self, raw_input_data: str, handle: int | None = None) -> str:
         """Runs handling of the input data on connector.
 
         NOTE: handle is actually a pointer address to spawn's internal state.
         In versions of SOAR >6.4.1, handle will not be passed to the app.
         """
-        input_data = InputSpecification.parse_obj(json.loads(raw_input_data))
+        input_data = InputSpecification.model_validate(json.loads(raw_input_data))
         self._raw_asset_config = input_data.config.get_asset_config()
 
         # Decrypt sensitive fields in the asset configuration
@@ -221,27 +222,27 @@ class App:
     def asset(self) -> BaseAsset:
         """Returns the asset instance for the app."""
         if not hasattr(self, "_asset"):
-            self._asset = self.asset_cls.parse_obj(self._raw_asset_config)
+            self._asset = self.asset_cls.model_validate(self._raw_asset_config)
         return self._asset
 
     def register_action(
         self,
         /,
-        action: Union[str, Callable],
+        action: str | Callable,
         *,
-        name: Optional[str] = None,
-        identifier: Optional[str] = None,
-        description: Optional[str] = None,
+        name: str | None = None,
+        identifier: str | None = None,
+        description: str | None = None,
         verbose: str = "",
         action_type: str = "generic",  # TODO: consider introducing enum type for that
         read_only: bool = True,
-        params_class: Optional[type[Params]] = None,
-        output_class: Optional[type[ActionOutput]] = None,
-        render_as: Optional[str] = None,
-        view_handler: Union[str, Callable, None] = None,
-        view_template: Optional[str] = None,
+        params_class: type[Params] | None = None,
+        output_class: type[ActionOutput] | None = None,
+        render_as: str | None = None,
+        view_handler: str | Callable | None = None,
+        view_template: str | None = None,
         versions: str = "EQ(*)",
-        summary_type: Optional[type[ActionOutput]] = None,
+        summary_type: type[ActionOutput] | None = None,
         enable_concurrency_lock: bool = False,
     ) -> Action:
         """Dynamically register an action function defined in another module.
@@ -415,18 +416,18 @@ class App:
     def action(
         self,
         *,
-        name: Optional[str] = None,
-        identifier: Optional[str] = None,
-        description: Optional[str] = None,
+        name: str | None = None,
+        identifier: str | None = None,
+        description: str | None = None,
         verbose: str = "",
         action_type: str = "generic",  # TODO: consider introducing enum type for that
         read_only: bool = True,
-        params_class: Optional[type[Params]] = None,
-        output_class: Optional[type[ActionOutput]] = None,
-        render_as: Optional[str] = None,
-        view_handler: Optional[Callable] = None,
+        params_class: type[Params] | None = None,
+        output_class: type[ActionOutput] | None = None,
+        render_as: str | None = None,
+        view_handler: Callable | None = None,
         versions: str = "EQ(*)",
-        summary_type: Optional[type[ActionOutput]] = None,
+        summary_type: type[ActionOutput] | None = None,
         enable_concurrency_lock: bool = False,
     ) -> ActionDecorator:
         """Decorator for registering an action function.
@@ -497,7 +498,7 @@ class App:
     def view_handler(
         self,
         *,
-        template: Optional[str] = None,
+        template: str | None = None,
     ) -> ViewHandlerDecorator:
         """Decorator for custom view functions with output parsing and template rendering.
 
@@ -525,7 +526,7 @@ class App:
         return ViewHandlerDecorator(self, template=template)
 
     def make_request(
-        self, output_class: Optional[type[ActionOutput]] = None
+        self, output_class: type[ActionOutput] | None = None
     ) -> MakeRequestDecorator:
         """Decorator for registering a ``make request`` action function.
 
@@ -556,7 +557,7 @@ class App:
     def _validate_params_class(
         action_name: str,
         spec: inspect.FullArgSpec,
-        params_class: Optional[type[Params]] = None,
+        params_class: type[Params] | None = None,
     ) -> type[Params]:
         """Validates the class used for params argument of the action.
 
@@ -572,7 +573,7 @@ class App:
                     "Action function must accept at least the params positional argument"
                 )
             params_arg = spec.args[0]
-            annotated_params_type: Optional[type] = spec.annotations.get(params_arg)
+            annotated_params_type: type | None = spec.annotations.get(params_arg)
             if annotated_params_type is None:
                 raise TypeError(
                     f"Action {action_name} has no params type set. "
@@ -594,7 +595,7 @@ class App:
         """
         # The reason we wrap values in callables is to avoid evaluating any lazy attributes
         # (like asset) unless they're actually going to be used in the action function.
-        magic_args: dict[str, Union[object, Callable[[], object]]] = {
+        magic_args: dict[str, object | Callable[[], object]] = {
             "soar": self.soar_client,
             "asset": lambda: self.asset,
         }
@@ -626,18 +627,16 @@ class App:
 
     @staticmethod
     def _adapt_action_result(
-        result: Union[
-            ActionOutput,
-            ActionResult,
-            list[ActionOutput],
-            Iterator[ActionOutput],
-            tuple[bool, str],
-            bool,
-        ],
+        result: ActionOutput
+        | ActionResult
+        | list[ActionOutput]
+        | Iterator[ActionOutput]
+        | tuple[bool, str]
+        | bool,
         actions_manager: ActionsManager,
-        action_params: Optional[Params] = None,
+        action_params: Params | None = None,
         message: str = "",
-        summary: Optional[ActionOutput] = None,
+        summary: ActionOutput | None = None,
     ) -> bool:
         """Handles multiple ways of returning response from action.
 
@@ -657,13 +656,21 @@ class App:
                 )
             # Handle empty list/iterator case
             if not statuses:
-                result = ActionOutput(status=True, message=message)
+                # Create ActionResult directly for empty list
+                param_dict = action_params.model_dump() if action_params else None
+                result = ActionResult(
+                    status=True,
+                    message=message,
+                    param=param_dict,
+                )
+                if summary:
+                    result.set_summary(summary.model_dump(by_alias=True))
             else:
                 return all(statuses)
 
         if isinstance(result, ActionOutput):
-            output_dict = result.dict(by_alias=True)
-            param_dict = action_params.dict() if action_params else None
+            output_dict = result.model_dump(by_alias=True)
+            param_dict = action_params.model_dump() if action_params else None
 
             result = ActionResult(
                 status=True,
@@ -672,7 +679,7 @@ class App:
             )
             result.add_data(output_dict)
             if summary:
-                result.set_summary(summary.dict(by_alias=True))
+                result.set_summary(summary.model_dump(by_alias=True))
 
         if isinstance(result, ActionResult):
             actions_manager.add_result(result)
@@ -695,14 +702,14 @@ class App:
 
             pytest.mark.skip(inner)
 
-    webhook_meta: Optional[WebhookMeta] = None
-    webhook_router: Optional[Router] = None
+    webhook_meta: WebhookMeta | None = None
+    webhook_router: Router | None = None
 
     def enable_webhooks(
         self,
         default_requires_auth: bool = True,
-        default_allowed_headers: Optional[list[str]] = None,
-        default_ip_allowlist: Optional[list[str]] = None,
+        default_allowed_headers: list[str] | None = None,
+        default_ip_allowlist: list[str] | None = None,
     ) -> "App":
         """Enable webhook functionality for the app.
 
@@ -731,7 +738,7 @@ class App:
             default_ip_allowlist = ["0.0.0.0/0", "::/0"]
 
         self.webhook_meta = WebhookMeta(
-            handler=None,  # The handler is set by the ManifestProcessor when generating the final manifest
+            handler=None,
             requires_auth=default_requires_auth,
             allowed_headers=default_allowed_headers,
             ip_allowlist=default_ip_allowlist,
@@ -742,7 +749,7 @@ class App:
         return self
 
     def webhook(
-        self, url_pattern: str, allowed_methods: Optional[list[str]] = None
+        self, url_pattern: str, allowed_methods: list[str] | None = None
     ) -> WebhookDecorator:
         """Decorator for registering a webhook handler."""
         return WebhookDecorator(self, url_pattern, allowed_methods)
@@ -752,8 +759,8 @@ class App:
         method: str,
         headers: dict[str, str],
         path_parts: list[str],
-        query: dict[str, Union[str, list[str], None]],
-        body: Optional[str],
+        query: dict[str, str | list[str] | None],
+        body: str | None,
         asset: dict,
         soar_rest_client: SoarRestClient,
     ) -> dict:
@@ -801,4 +808,4 @@ class App:
             raise TypeError(
                 f"Webhook handler must return a WebhookResponse, got {type(response)}"
             )
-        return response.dict()
+        return response.model_dump()

soar_sdk/app_cli_runner.py

@@ -3,7 +3,7 @@ import inspect
 import json
 from pathlib import Path
 import typing
-from typing import Optional, Any
+from typing import Any
 import os
 from pydantic import ValidationError
 from urllib.parse import urlparse, parse_qs
@@ -31,7 +31,7 @@ class AppCliRunner:
     def __init__(self, app: "App") -> None:
         self.app = app
 
-    def parse_args(self, argv: Optional[list[str]] = None) -> argparse.Namespace:
+    def parse_args(self, argv: list[str] | None = None) -> argparse.Namespace:
         """Parse command line arguments for the app CLI runner."""
         root_parser = argparse.ArgumentParser()
         root_parser.add_argument(
@@ -162,13 +162,13 @@ class AppCliRunner:
                 )
 
             try:
-                param = chosen_action.params_class.parse_obj(params_json)
+                param = chosen_action.params_class.model_validate(params_json)
             except Exception as e:
                 root_parser.error(
                     f"Unable to parse parameter JSON file {params_file}:\n{e}"
                 )
 
-            parameter_list.append(ActionParameter(**param.dict()))
+            parameter_list.append(ActionParameter(**param.model_dump()))
 
         input_data = InputSpecification(
             action=args.identifier,
@@ -191,7 +191,7 @@ class AppCliRunner:
                 )
 
         input_data.config = AppConfig(
-            **input_data.config.dict(),
+            **input_data.config.model_dump(),
             **asset_json,  # Merge asset JSON into config
         )
 
@@ -207,7 +207,7 @@ class AppCliRunner:
             except ValidationError as e:
                 root_parser.error(f"Provided soar auth arguments are invalid: {e}.")
 
-        args.raw_input_data = input_data.json()
+        args.raw_input_data = input_data.model_dump_json()
 
     def _parse_webhook_args(
         self,
@@ -250,14 +250,14 @@ class AppCliRunner:
             path_parts=path_parts,
             query=query,
             body=args.data,
-            asset=self.app.asset_cls.parse_obj(asset_json),
+            asset=self.app.asset_cls.model_validate(asset_json),
             soar_base_url=soar_base_url,
             soar_auth_token=soar_auth_token,
             asset_id=args.asset_id,
         )
         print(f"Parsed webhook request: {args.webhook_request}")
 
-    def run(self, argv: Optional[list[str]] = None) -> None:
+    def run(self, argv: list[str] | None = None) -> None:
         """Run the app CLI."""
         args = self.parse_args(argv=argv)
 

soar_sdk/app_client.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Any, TYPE_CHECKING, Union, Optional
+from typing import Any, TYPE_CHECKING
 from collections.abc import Mapping
 
 import httpx
@@ -41,9 +41,9 @@ class AppClient(SOARClient[SummaryType]):
         self._artifacts_api = Artifact(soar_client=self)
         self._containers_api = Container(soar_client=self)
         self._vault_api = Vault(soar_client=self)
-        self.basic_auth: Optional[BasicAuth] = None
+        self.basic_auth: BasicAuth | None = None
 
-        self._summary: Optional[SummaryType] = None
+        self._summary: SummaryType | None = None
         self._message: str = ""
         self.__container_id: int = 0
         self.__asset_id: str = ""
@@ -132,13 +132,13 @@ class AppClient(SOARClient[SummaryType]):
         self,
         endpoint: str,
         *,
-        params: Optional[Union[dict[str, Any], httpx.QueryParams]] = None,
-        headers: Optional[dict[str, str]] = None,
-        cookies: Optional[dict[str, str]] = None,
-        auth: Optional[Union[httpx.Auth, tuple[str, str]]] = None,
-        timeout: Optional[httpx.Timeout] = None,
+        params: dict[str, Any] | httpx.QueryParams | None = None,
+        headers: dict[str, str] | None = None,
+        cookies: dict[str, str] | None = None,
+        auth: httpx.Auth | tuple[str, str] | None = None,
+        timeout: httpx.Timeout | None = None,
         follow_redirects: bool = False,
-        extensions: Optional[Mapping[str, Any]] = None,
+        extensions: Mapping[str, Any] | None = None,
     ) -> httpx.Response:
         """Perform a DELETE request to the specific endpoint using the SOAR client."""
         headers = headers or {}
@@ -167,7 +167,7 @@ class AppClient(SOARClient[SummaryType]):
         """Set the message for the action result."""
         self._message = message
 
-    def get_summary(self) -> Optional[SummaryType]:
+    def get_summary(self) -> SummaryType | None:
         """Get the summary for the action result."""
         return self._summary
 

soar_sdk/asset.py

@@ -1,14 +1,16 @@
-from typing import Any, Optional, Union
+from typing import Any
 from zoneinfo import ZoneInfo
-from pydantic import BaseModel, root_validator
-from pydantic.fields import Field, Undefined
+from pydantic import BaseModel, model_validator, ConfigDict, Field
+from pydantic_core import PydanticUndefined
 
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import TypedDict
+from typing import NotRequired
 
 
 from soar_sdk.compat import remove_when_soar_newer_than
 from soar_sdk.meta.datatypes import as_datatype
 from soar_sdk.input_spec import AppConfig
+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+"
@@ -16,12 +18,12 @@ remove_when_soar_newer_than(
 
 
 def AssetField(
-    description: Optional[str] = None,
+    description: str | None = None,
     required: bool = True,
-    default: Optional[Any] = None,  # noqa: ANN401
-    value_list: Optional[list] = None,
+    default: Any | None = None,  # noqa: ANN401
+    value_list: list | None = None,
     sensitive: bool = False,
-    alias: Optional[str] = None,
+    alias: str | None = None,
 ) -> Any:  # noqa: ANN401
     """Representation of an asset configuration field.
 
@@ -42,13 +44,22 @@ def AssetField(
     Returns:
         The FieldInfo object as pydantic.Field.
     """
+    json_schema_extra: dict[str, Any] = {}
+    if required is not None:
+        json_schema_extra["required"] = required
+    if value_list is not None:
+        json_schema_extra["value_list"] = value_list
+    if sensitive is not None:
+        json_schema_extra["sensitive"] = sensitive
+
+    # 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,
-        value_list=value_list,
-        sensitive=sensitive,
         alias=alias,
+        json_schema_extra=json_schema_extra if json_schema_extra else None,
     )
 
 
@@ -71,7 +82,7 @@ class AssetFieldSpecification(TypedDict):
     data_type: str
     description: NotRequired[str]
     required: NotRequired[bool]
-    default: NotRequired[Union[str, int, float, bool]]
+    default: NotRequired[str | int | float | bool]
     value_list: NotRequired[list[str]]
     order: NotRequired[int]
 
@@ -106,16 +117,12 @@ class BaseAsset(BaseModel):
         the SOAR platform to avoid conflicts with internal fields.
     """
 
-    class Config:
-        """Pydantic configuration for BaseAsset.
-
-        Note that we are using the `arbitrary_types_allowed` setting, which is generally not recommended.
-        However, we are checking all of the field types via `soar_sdk.datatypes.as_datatype`, so we have confidence in their validity.
-        """
-
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def validate_no_reserved_fields(cls, values: dict[str, Any]) -> dict[str, Any]:
         """Prevents subclasses from defining fields starting with "_reserved_".
 
@@ -148,7 +155,7 @@ class BaseAsset(BaseModel):
             # This accounts for some bad behavior by the platform; it injects a few app-related
             # metadata fields directly into asset configuration dictionaries, which can lead to
             # undefined behavior if an asset tries to use the same field names.
-            if field_name in AppConfig.__fields__:
+            if field_name in AppConfig.model_fields:
                 raise ValueError(
                     f"Field name '{field_name}' is reserved by the platform and cannot be used in an asset"
                 )
@@ -206,8 +213,10 @@ class BaseAsset(BaseModel):
         """
         params: dict[str, AssetFieldSpecification] = {}
 
-        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:
+                continue
 
             try:
                 type_name = as_datatype(field_type)
@@ -216,32 +225,34 @@ class BaseAsset(BaseModel):
                     f"Failed to serialize asset field {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 = AssetFieldSpecification(
                 data_type=type_name,
-                required=field.field_info.extra.get("required", True),
+                required=bool(json_schema_extra.get("required", True)),
                 description=description,
                 order=field_order,
             )
 
-            if (default := field.field_info.default) and default != Undefined:
+            if (default := field.default) not in (PydanticUndefined, None):
                 if isinstance(default, ZoneInfo):
                     params_field["default"] = default.key
                 else:
                     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
 
@@ -255,8 +266,9 @@ class BaseAsset(BaseModel):
         """
         return {
             field_name
-            for field_name, field in cls.__fields__.items()
-            if field.field_info.extra.get("sensitive", False)
+            for field_name, field in cls.model_fields.items()
+            if isinstance(field.json_schema_extra, dict)
+            and field.json_schema_extra.get("sensitive", False)
         }
 
     @classmethod
@@ -268,6 +280,6 @@ class BaseAsset(BaseModel):
         """
         return {
             field_name
-            for field_name, field in cls.__fields__.items()
+            for field_name, field in cls.model_fields.items()
             if field.annotation is ZoneInfo
         }

soar_sdk/async_utils.py

@@ -17,7 +17,7 @@ def is_async_generator(obj: Any) -> bool:  # noqa: ANN401
     return inspect.isasyncgen(obj)
 
 
-async def async_generator_to_list(agen: AsyncGenerator[T, None]) -> list[T]:
+async def async_generator_to_list(agen: AsyncGenerator[T]) -> list[T]:
     """Consume an async generator and return its items in a list."""
     result: list[T] = []
     # Python 3.9 coverage limitation with async for loops
@@ -31,7 +31,7 @@ def run_async_if_needed(result: Coroutine[Any, Any, T]) -> T: ...
 
 
 @overload
-def run_async_if_needed(result: AsyncGenerator[T, None]) -> list[T]: ...
+def run_async_if_needed(result: AsyncGenerator[T]) -> list[T]: ...
 
 
 @overload

soar_sdk/cli/init/cli.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Optional, cast
+from typing import Annotated, cast
 import datetime
 import json
 import os
@@ -65,7 +65,7 @@ def init_callback(
     type: str = "generic",  # noqa: A002
     vendor: str = "Splunk Inc.",
     publisher: str = "Splunk Inc.",
-    product: Optional[str] = None,
+    product: str | None = None,
     fips_compliant: bool = False,
     overwrite: bool = False,
 ) -> None:
@@ -107,11 +107,11 @@ def init_sdk_app(
     publisher: str,
     logo: Path,
     logo_dark: Path,
-    product: Optional[str] = None,
+    product: str | None = None,
     fips_compliant: bool = False,
     overwrite: bool = False,
-    app_content: Optional[list[ast.stmt]] = None,
-    asset_class: Optional[ast.ClassDef] = None,
+    app_content: list[ast.stmt] | None = None,
+    asset_class: ast.ClassDef | None = None,
 ) -> None:
     """Initialize a new SOAR app in the specified directory."""
     app_dir.mkdir(exist_ok=True)
@@ -149,9 +149,7 @@ def init_sdk_app(
         name=name,
         version=version,
         description=description,
-        copyright=copyright.format(
-            year=datetime.datetime.now(datetime.timezone.utc).year
-        ),
+        copyright=copyright.format(year=datetime.datetime.now(datetime.UTC).year),
         python_versions=python_versions,
         authors=authors,
         dependencies=dependencies,
@@ -242,7 +240,7 @@ def convert_connector_to_sdk(
         ),
     ],
     output_dir: Annotated[
-        Optional[Path],
+        Path | None,
         typer.Argument(
             file_okay=False,
             dir_okay=True,