piphi-runtime-kit-python 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

piphi_runtime_kit_python/__init__.py

@@ -1,3 +1,17 @@
+from .automations import (
+    AutomationActionDefinition,
+    AutomationActionRequest,
+    AutomationActionResult,
+    AutomationClient,
+    AutomationContractReport,
+    AutomationEventDefinition,
+    AutomationIdempotencyStore,
+    AutomationRegistry,
+    InMemoryAutomationIdempotencyStore,
+    assert_behaviors_contract,
+    audit_behaviors_contract,
+    build_mock_automation_event,
+)
 from .runtime.auth import (
     RUNTIME_CONTAINER_ID_HEADER_NAME,
     RUNTIME_INTERNAL_TOKEN_HEADER_NAME,
@@ -63,7 +77,10 @@ from .runtime.events import (
     format_event_log,
     normalize_event_payload,
 )
-from .runtime.health import build_runtime_diagnostics_response, build_runtime_health_response
+from .runtime.health import (
+    build_runtime_diagnostics_response,
+    build_runtime_health_response,
+)
 from .runtime.identity import (
     RuntimeDeviceRef,
     RuntimeIdentityError,
@@ -92,8 +109,17 @@ from .runtime.mqtt import (
 )
 from .runtime.registry import RuntimeRegistry
 from .runtime.state import RuntimeProcessState
-from .runtime.starter import RuntimeStarter, build_entities_response, create_runtime_starter
-from .runtime.tasks import create_tracked_task, shutdown_background_tasks, track_background_task
+from .runtime.starter import (
+    RuntimeStarter,
+    build_entities_response,
+    create_runtime_starter,
+)
+from .runtime.tasks import (
+    BackgroundTaskLimitError,
+    create_tracked_task,
+    shutdown_background_tasks,
+    track_background_task,
+)
 from .runtime.telemetry import (
     TelemetryClient,
     TelemetryReading,
@@ -127,6 +153,16 @@ from .schemas import (
 )
 
 __all__ = [
+    "AutomationActionDefinition",
+    "AutomationActionRequest",
+    "AutomationActionResult",
+    "AutomationClient",
+    "AutomationContractReport",
+    "AutomationEventDefinition",
+    "AutomationIdempotencyStore",
+    "AutomationRegistry",
+    "InMemoryAutomationIdempotencyStore",
+    "BackgroundTaskLimitError",
     "ConfigSyncCoordinator",
     "CoreAuthError",
     "CoreDeliveryError",
@@ -180,6 +216,7 @@ __all__ = [
     "IntegrationEventIngestResponse",
     "IntegrationEventListResponse",
     "build_runtime_config_snapshot_from_core_rows",
+    "build_mock_automation_event",
     "build_discovery_response",
     "classify_core_delivery_error",
     "build_core_event_payload",
@@ -228,6 +265,8 @@ __all__ = [
     "resolve_device_id",
     "validate_typed_config",
     "validate_typed_configs",
+    "assert_behaviors_contract",
+    "audit_behaviors_contract",
     "DEFAULT_SOURCE_TOPIC_PREFIX",
     "build_source_errors_topic",
     "build_source_model_packets_topic",

piphi_runtime_kit_python/adapters/fastapi.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Mapping
 
+from ..automations import AutomationActionResult, AutomationRegistry
 from ..runtime.auth import RuntimeAuthHeaders
 from ..runtime.context import RuntimeContext
 
@@ -11,6 +12,31 @@ if TYPE_CHECKING:
     from fastapi import Request
 
 
+async def dispatch_automation_action_from_fastapi(
+    registry: AutomationRegistry,
+    request: "Request",
+    payload: object | Mapping[str, Any],
+) -> AutomationActionResult:
+    """Dispatch a Core command while preserving its stable idempotency key.
+
+    The key is accepted from the canonical header first and then from the JSON
+    payload for compatibility with runtimes that proxy requests internally.
+    """
+    payload_data = (
+        dict(payload)
+        if isinstance(payload, Mapping)
+        else payload.model_dump(mode="python")
+        if hasattr(payload, "model_dump")
+        else dict(vars(payload))
+    )
+    header_key = str(request.headers.get("X-PiPhi-Idempotency-Key") or "").strip()
+    payload_key = str(payload_data.get("idempotency_key") or "").strip()
+    return await registry.dispatch(
+        payload_data,
+        idempotency_key=header_key or payload_key or None,
+    )
+
+
 def get_payload_container_id(
     payload: object | Mapping[str, Any] | None,
     *,

piphi_runtime_kit_python/automations.py

@@ -0,0 +1,416 @@
+"""Typed automation helpers for PiPhi integration runtimes.
+
+``behaviors.json`` remains the declarative catalog consumed by Core and the
+builders.  This module implements the runtime half of that contract: emitting
+declared events, dispatching declared actions, preserving idempotency keys, and
+checking that runtime handlers match the published behavior schema.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass
+from typing import Any, Literal, Protocol, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .runtime.auth import RuntimeAuthContext
+from .runtime.events import EventClient, build_core_event_payload
+from .runtime.identity import RuntimeDeviceRef
+from .schemas import CoreEventPayload, EventSeverity
+
+class AutomationActionRequest(BaseModel):
+    """Normalized action request received from PiPhi Core."""
+
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    command: str = Field(min_length=1)
+    args: dict[str, Any] = Field(default_factory=dict)
+    idempotency_key: str | None = None
+    command_id: str | None = None
+    correlation_id: str | None = None
+    integration_id: str | None = None
+    config_id: str | None = None
+    container_id: str | None = None
+    device_id: str | None = None
+    entity_id: str | None = None
+    capability_id: str | None = None
+    run_id: str | None = None
+    node_id: str | None = None
+
+
+class AutomationActionResult(BaseModel):
+    """Structured result returned by an automation action handler."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    status: Literal["success", "failed"]
+    result: dict[str, Any] = Field(default_factory=dict)
+    error: str | None = None
+    retryable: bool = False
+    metadata: dict[str, Any] = Field(default_factory=dict)
+    replayed: bool = False
+
+    @property
+    def ok(self) -> bool:
+        return self.status == "success"
+
+    @classmethod
+    def success(
+        cls,
+        result: Mapping[str, Any] | None = None,
+        **values: Any,
+    ) -> "AutomationActionResult":
+        payload = dict(result or {})
+        payload.update(values)
+        return cls(status="success", result=payload)
+
+    @classmethod
+    def failure(
+        cls,
+        error: str,
+        *,
+        retryable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+    ) -> "AutomationActionResult":
+        return cls(
+            status="failed",
+            error=str(error),
+            retryable=retryable,
+            metadata=dict(metadata or {}),
+        )
+
+
+AutomationHandlerValue: TypeAlias = (
+    AutomationActionResult | Mapping[str, Any] | None
+)
+AutomationActionHandler: TypeAlias = Callable[
+    [AutomationActionRequest],
+    AutomationHandlerValue | Awaitable[AutomationHandlerValue],
+]
+
+
+class AutomationIdempotencyStore(Protocol):
+    """Persistence contract for action results keyed by Core idempotency key."""
+
+    async def get(self, key: str) -> AutomationActionResult | None: ...
+
+    async def put(self, key: str, result: AutomationActionResult) -> None: ...
+
+
+class InMemoryAutomationIdempotencyStore:
+    """Process-local idempotency store for development and tests.
+
+    Production runtimes should provide a durable implementation when an action
+    changes external state. Core supplies a stable key, but the runtime owns the
+    device-side effect and therefore must persist the final outcome.
+    """
+
+    def __init__(self) -> None:
+        self._results: dict[str, AutomationActionResult] = {}
+
+    async def get(self, key: str) -> AutomationActionResult | None:
+        result = self._results.get(key)
+        return result.model_copy(deep=True) if result else None
+
+    async def put(self, key: str, result: AutomationActionResult) -> None:
+        self._results[key] = result.model_copy(deep=True)
+
+
+@dataclass(frozen=True, slots=True)
+class AutomationActionDefinition:
+    command: str
+    label: str
+    parameter_schema: Mapping[str, Any]
+    result_schema: Mapping[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class AutomationEventDefinition:
+    event_type: str
+    label: str
+    data_schema: Mapping[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class AutomationContractReport:
+    missing_action_handlers: tuple[str, ...]
+    missing_event_publishers: tuple[str, ...]
+    undeclared_action_handlers: tuple[str, ...]
+    undeclared_event_publishers: tuple[str, ...]
+
+    @property
+    def ok(self) -> bool:
+        return not any(
+            (
+                self.missing_action_handlers,
+                self.missing_event_publishers,
+                self.undeclared_action_handlers,
+                self.undeclared_event_publishers,
+            )
+        )
+
+    def messages(self) -> tuple[str, ...]:
+        groups = (
+            ("Missing action handlers", self.missing_action_handlers),
+            ("Missing event publishers", self.missing_event_publishers),
+            ("Handlers absent from behaviors.json", self.undeclared_action_handlers),
+            ("Events absent from behaviors.json", self.undeclared_event_publishers),
+        )
+        return tuple(f"{label}: {', '.join(values)}" for label, values in groups if values)
+
+
+class AutomationRegistry:
+    """Registry for typed runtime action handlers and event definitions."""
+
+    def __init__(
+        self,
+        *,
+        idempotency_store: AutomationIdempotencyStore | None = None,
+    ) -> None:
+        self.idempotency_store = idempotency_store
+        self._actions: dict[str, tuple[AutomationActionDefinition, AutomationActionHandler]] = {}
+        self._events: dict[str, AutomationEventDefinition] = {}
+        self._key_locks: dict[str, asyncio.Lock] = {}
+
+    @property
+    def action_definitions(self) -> tuple[AutomationActionDefinition, ...]:
+        return tuple(item[0] for item in self._actions.values())
+
+    @property
+    def event_definitions(self) -> tuple[AutomationEventDefinition, ...]:
+        return tuple(self._events.values())
+
+    def action(
+        self,
+        command: str,
+        *,
+        label: str | None = None,
+        parameter_schema: Mapping[str, Any] | None = None,
+        result_schema: Mapping[str, Any] | None = None,
+    ) -> Callable[[AutomationActionHandler], AutomationActionHandler]:
+        """Register an action handler while preserving its builder schemas."""
+        normalized = str(command or "").strip()
+        if not normalized:
+            raise ValueError("Automation action command cannot be empty")
+
+        def decorator(handler: AutomationActionHandler) -> AutomationActionHandler:
+            if normalized in self._actions:
+                raise ValueError(f"Automation action '{normalized}' is already registered")
+            definition = AutomationActionDefinition(
+                command=normalized,
+                label=str(label or normalized).strip(),
+                parameter_schema=dict(parameter_schema or {}),
+                result_schema=dict(result_schema or {}),
+            )
+            self._actions[normalized] = (definition, handler)
+            return handler
+
+        return decorator
+
+    def event(
+        self,
+        event_type: str,
+        *,
+        label: str | None = None,
+        data_schema: Mapping[str, Any] | None = None,
+    ) -> AutomationEventDefinition:
+        """Declare an event the integration may publish."""
+        normalized = str(event_type or "").strip()
+        if not normalized:
+            raise ValueError("Automation event type cannot be empty")
+        if normalized in self._events:
+            raise ValueError(f"Automation event '{normalized}' is already registered")
+        definition = AutomationEventDefinition(
+            event_type=normalized,
+            label=str(label or normalized).strip(),
+            data_schema=dict(data_schema or {}),
+        )
+        self._events[normalized] = definition
+        return definition
+
+    async def dispatch(
+        self,
+        request: AutomationActionRequest | Mapping[str, Any],
+        *,
+        idempotency_key: str | None = None,
+    ) -> AutomationActionResult:
+        """Validate and dispatch an action, replaying durable terminal outcomes."""
+        action_request = (
+            request
+            if isinstance(request, AutomationActionRequest)
+            else AutomationActionRequest.model_validate(request)
+        )
+        if idempotency_key:
+            action_request = action_request.model_copy(
+                update={"idempotency_key": str(idempotency_key).strip() or None}
+            )
+        registered = self._actions.get(action_request.command)
+        if registered is None:
+            return AutomationActionResult.failure(
+                f"Unknown automation action '{action_request.command}'",
+                retryable=False,
+            )
+
+        scoped_key = (
+            f"{action_request.command}:{action_request.idempotency_key}"
+            if action_request.idempotency_key
+            else ""
+        )
+        if scoped_key and self.idempotency_store is not None:
+            lock = self._key_locks.setdefault(scoped_key, asyncio.Lock())
+            async with lock:
+                cached = await self.idempotency_store.get(scoped_key)
+                if cached is not None:
+                    return cached.model_copy(update={"replayed": True})
+                result = await self._invoke(registered[1], action_request)
+                if result.ok or not result.retryable:
+                    await self.idempotency_store.put(scoped_key, result)
+                return result
+        return await self._invoke(registered[1], action_request)
+
+    async def _invoke(
+        self,
+        handler: AutomationActionHandler,
+        request: AutomationActionRequest,
+    ) -> AutomationActionResult:
+        try:
+            candidate = handler(request)
+            value = await candidate if isinstance(candidate, Awaitable) else candidate
+            if isinstance(value, AutomationActionResult):
+                return value
+            if value is None:
+                return AutomationActionResult.success()
+            if isinstance(value, Mapping):
+                return AutomationActionResult.success(value)
+            return AutomationActionResult.failure(
+                "Automation handler returned an unsupported result type"
+            )
+        except Exception as exc:
+            return AutomationActionResult.failure(str(exc), retryable=False)
+
+    def contract_snapshot(self) -> dict[str, Any]:
+        """Return stable JSON data for conformance snapshots and tooling."""
+        return {
+            "actions": [
+                {
+                    "command": item.command,
+                    "label": item.label,
+                    "parameter_schema": dict(item.parameter_schema),
+                    "result_schema": dict(item.result_schema),
+                }
+                for item in self.action_definitions
+            ],
+            "events": [
+                {
+                    "event_type": item.event_type,
+                    "label": item.label,
+                    "data_schema": dict(item.data_schema),
+                }
+                for item in self.event_definitions
+            ],
+        }
+
+
+@dataclass(slots=True)
+class AutomationClient:
+    """High-level automation event publisher backed by the existing EventClient."""
+
+    event_client: EventClient
+    auth_context: RuntimeAuthContext
+    registry: AutomationRegistry | None = None
+
+    async def emit(
+        self,
+        event_type: str,
+        *,
+        device: RuntimeDeviceRef | Mapping[str, Any],
+        data: Mapping[str, Any] | None = None,
+        source: str | None = None,
+        severity: EventSeverity | str = EventSeverity.info,
+        event_id: str | None = None,
+    ) -> bool:
+        if self.registry is not None and event_type not in {
+            item.event_type for item in self.registry.event_definitions
+        }:
+            raise ValueError(f"Automation event '{event_type}' is not registered")
+        return await self.event_client.send_device_event(
+            device=device,
+            event_type=event_type,
+            auth_context=self.auth_context,
+            payload=data,
+            source=source,
+            severity=severity,
+            event_id=event_id,
+        )
+
+
+def build_mock_automation_event(
+    event_type: str,
+    *,
+    data: Mapping[str, Any] | None = None,
+    integration_id: str = "mock-integration",
+    config_id: str = "mock-config",
+    container_id: str = "mock-container",
+    device_id: str = "mock-device",
+    event_id: str | None = None,
+) -> CoreEventPayload:
+    """Create a canonical, non-dispatched event fixture for automated tests."""
+    return build_core_event_payload(
+        event_type=event_type,
+        integration_id=integration_id,
+        config_id=config_id,
+        container_id=container_id,
+        device_id=device_id,
+        payload=data,
+        source="automation-sdk-mock",
+        event_id=event_id,
+    )
+
+
+def audit_behaviors_contract(
+    behaviors: Mapping[str, Any],
+    registry: AutomationRegistry,
+) -> AutomationContractReport:
+    """Compare runtime registrations with commands/events in ``behaviors.json``."""
+    declared_actions: set[str] = set()
+    declared_events: set[str] = set()
+    devices = behaviors.get("devices", [])
+    if not isinstance(devices, list):
+        devices = []
+    for device in devices:
+        if not isinstance(device, Mapping):
+            continue
+        actions = device.get("actions", [])
+        triggers = device.get("triggers", [])
+        for action in actions if isinstance(actions, list) else []:
+            if not isinstance(action, Mapping):
+                continue
+            runtime = action.get("runtime")
+            if isinstance(runtime, Mapping) and runtime.get("command"):
+                declared_actions.add(str(runtime["command"]).strip())
+        for trigger in triggers if isinstance(triggers, list) else []:
+            if not isinstance(trigger, Mapping):
+                continue
+            runtime = trigger.get("runtime")
+            if isinstance(runtime, Mapping) and runtime.get("event"):
+                declared_events.add(str(runtime["event"]).strip())
+
+    registered_actions = {item.command for item in registry.action_definitions}
+    registered_events = {item.event_type for item in registry.event_definitions}
+    return AutomationContractReport(
+        missing_action_handlers=tuple(sorted(declared_actions - registered_actions)),
+        missing_event_publishers=tuple(sorted(declared_events - registered_events)),
+        undeclared_action_handlers=tuple(sorted(registered_actions - declared_actions)),
+        undeclared_event_publishers=tuple(sorted(registered_events - declared_events)),
+    )
+
+
+def assert_behaviors_contract(
+    behaviors: Mapping[str, Any],
+    registry: AutomationRegistry,
+) -> None:
+    report = audit_behaviors_contract(behaviors, registry)
+    if not report.ok:
+        raise ValueError("; ".join(report.messages()))

piphi_runtime_kit_python/fastapi.py

@@ -1,12 +1,14 @@
 """Convenience re-exports for the optional FastAPI adapter layer."""
 
 from .adapters.fastapi import (
+    dispatch_automation_action_from_fastapi,
     get_payload_container_id,
     sync_runtime_auth_from_fastapi_payload,
     sync_runtime_auth_from_fastapi_request,
 )
 
 __all__ = [
+    "dispatch_automation_action_from_fastapi",
     "get_payload_container_id",
     "sync_runtime_auth_from_fastapi_payload",
     "sync_runtime_auth_from_fastapi_request",

piphi_runtime_kit_python/py.typed

@@ -0,0 +1 @@
+

piphi_runtime_kit_python/runtime/__init__.py

@@ -8,7 +8,11 @@ from .auth import (
     format_runtime_auth_sync_log,
     mask_token,
 )
-from .config_sync import ConfigSyncCoordinator, build_sync_response, reconcile_config_ids
+from .config_sync import (
+    ConfigSyncCoordinator,
+    build_sync_response,
+    reconcile_config_ids,
+)
 from .configuration import (
     build_config_apply_response,
     build_config_remove_response,
@@ -61,7 +65,12 @@ from .lifespan import (
 from .registry import RuntimeRegistry
 from .state import RuntimeProcessState
 from .starter import RuntimeStarter, create_runtime_starter
-from .tasks import create_tracked_task, shutdown_background_tasks, track_background_task
+from .tasks import (
+    BackgroundTaskLimitError,
+    create_tracked_task,
+    shutdown_background_tasks,
+    track_background_task,
+)
 from .telemetry import (
     TelemetryClient,
     TelemetryReading,
@@ -71,6 +80,7 @@ from .telemetry import (
 )
 
 __all__ = [
+    "BackgroundTaskLimitError",
     "ConfigSyncCoordinator",
     "CoreAuthError",
     "CoreDeliveryError",

piphi_runtime_kit_python/runtime/auth.py

@@ -7,9 +7,9 @@ from dataclasses import dataclass
 from typing import Any, Mapping
 
 
-DEFAULT_INTERNAL_TOKEN_ENV_NAME = "PIPHI_INTEGRATION_INTERNAL_TOKEN"
+DEFAULT_INTERNAL_TOKEN_ENV_NAME = "PIPHI_INTEGRATION_INTERNAL_TOKEN"  # nosec B105
 RUNTIME_CONTAINER_ID_HEADER_NAME = "X-Container-Id"
-RUNTIME_INTERNAL_TOKEN_HEADER_NAME = "X-PiPhi-Integration-Token"
+RUNTIME_INTERNAL_TOKEN_HEADER_NAME = "X-PiPhi-Integration-Token"  # nosec B105
 
 
 def mask_token(token: str | None) -> str:
@@ -32,6 +32,7 @@ def _get_header_value(headers: Mapping[str, Any], name: str) -> str:
 @dataclass(slots=True, frozen=True)
 class RuntimeAuthHeaders:
     """Normalized PiPhi runtime auth values extracted from request headers."""
+
     container_id: str = ""
     internal_token: str = ""
 
@@ -81,6 +82,7 @@ class RuntimeAuthContext:
     Integrations can keep the most recent container scope and internal token here,
     then reuse it for outbound telemetry or config sync calls.
     """
+
     container_id: str = ""
     internal_token: str = ""
 
@@ -130,5 +132,7 @@ class RuntimeAuthContext:
     ) -> tuple[str, str]:
         """Resolve the effective container scope and internal token for a request."""
         resolved_container_id = str(container_id or "").strip() or self.container_id
-        resolved_internal_token = self.internal_token or (os.getenv(token_env_name) or "").strip()
+        resolved_internal_token = (
+            self.internal_token or (os.getenv(token_env_name) or "").strip()
+        )
         return resolved_container_id, resolved_internal_token

piphi_runtime_kit_python/runtime/config_sync.py

@@ -36,7 +36,9 @@ def resolve_core_base_url(default: str | None = None) -> str | None:
     value = (os.getenv(CORE_BASE_URL_ENV_NAME) or "").strip().rstrip("/")
     if value:
         return value
-    return default.rstrip("/") if isinstance(default, str) and default.strip() else default
+    return (
+        default.rstrip("/") if isinstance(default, str) and default.strip() else default
+    )
 
 
 def resolve_runtime_config_snapshot_path(
@@ -164,7 +166,7 @@ def build_runtime_config_snapshot_from_core_rows(
     rows: list[dict[str, Any]],
     *,
     container_id: str,
-    config_model: type[TConfig] = RuntimeConfig,
+    config_model: type[TConfig] = RuntimeConfig,  # type: ignore[assignment]
     snapshot_model: type[Any] = RuntimeConfigSnapshot,
     reason: str = "startup_rehydrate",
 ) -> Any:
@@ -200,7 +202,7 @@ async def fetch_core_runtime_config_snapshot(
     runtime_context: RuntimeContext,
     client: httpx.AsyncClient,
     core_base_url: str | None = None,
-    config_model: type[TConfig] = RuntimeConfig,
+    config_model: type[TConfig] = RuntimeConfig,  # type: ignore[assignment]
     snapshot_model: type[Any] = RuntimeConfigSnapshot,
     timeout_seconds: float = DEFAULT_CORE_CLIENT_TIMEOUT_SECONDS,
     reason: str = "startup_rehydrate",
@@ -247,7 +249,7 @@ async def rehydrate_runtime_configs(
     runtime_context: RuntimeContext,
     client: httpx.AsyncClient,
     apply_snapshot: SnapshotApplyCallable,
-    config_model: type[TConfig] = RuntimeConfig,
+    config_model: type[TConfig] = RuntimeConfig,  # type: ignore[assignment]
     snapshot_model: type[Any] = RuntimeConfigSnapshot,
     core_base_url: str | None = None,
     timeout_seconds: float = DEFAULT_CORE_CLIENT_TIMEOUT_SECONDS,
@@ -338,7 +340,7 @@ def build_sync_response(
     applied: list[str] | None = None,
     removed: list[str] | None = None,
     active_config_ids: list[str] | None = None,
-    metadata: dict | None = None,
+    metadata: dict[str, Any] | None = None,
 ) -> RuntimeConfigSyncResponse:
     """Build a standard PiPhi config-sync response payload."""
     return RuntimeConfigSyncResponse(
@@ -360,6 +362,7 @@ class ConfigSyncCoordinator:
     This class intentionally stays small. It helps integrations decide whether
     an incoming snapshot is stale and keeps generation tracking in one place.
     """
+
     process_state: RuntimeProcessState
 
     def get_current_generation(self) -> int | None:
@@ -443,7 +446,9 @@ class ConfigSyncCoordinator:
 
         current_generation = self.mark_generation(snapshot.generation)
         next_active_config_ids = (
-            get_active_config_ids() if get_active_config_ids is not None else incoming_ids
+            get_active_config_ids()
+            if get_active_config_ids is not None
+            else incoming_ids
         )
 
         return build_sync_response(