py-data-engine 0.1.0__py3-none-any.whl

data_engine/domain/operations.py

@@ -0,0 +1,172 @@
+"""Domain models for selected-flow operation and step session state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from data_engine.domain.logs import RuntimeStepEvent
+
+
+@dataclass(frozen=True)
+class OperationRowState:
+    """Display-ready state for one step row."""
+
+    status: str = "idle"
+    started_at: float | None = None
+    elapsed_seconds: float | None = None
+
+    def started(self, *, now: float) -> "OperationRowState":
+        """Return the running state for one started step."""
+        return type(self)(status="running", started_at=now, elapsed_seconds=None)
+
+    def finished(self, *, status: str, elapsed_seconds: float | None) -> "OperationRowState":
+        """Return the completed state for one finished step."""
+        return type(self)(status=status, started_at=None, elapsed_seconds=elapsed_seconds)
+
+    def normalized(self) -> "OperationRowState":
+        """Return the normalized post-success idle state."""
+        if self.status != "success":
+            return self
+        return type(self)(status="idle", started_at=None, elapsed_seconds=self.elapsed_seconds)
+
+    def duration_text(self, *, now: float, formatter) -> str:
+        """Return the formatted visible duration for this row."""
+        if self.status == "running" and isinstance(self.started_at, (int, float)):
+            return formatter(now - float(self.started_at))
+        if isinstance(self.elapsed_seconds, (int, float)):
+            return formatter(float(self.elapsed_seconds))
+        return ""
+
+
+@dataclass(frozen=True)
+class OperationFlowState:
+    """Tracked step state for one flow."""
+
+    current_index: int | None = None
+    rows: dict[str, OperationRowState] = field(default_factory=dict)
+
+    @classmethod
+    def from_operation_names(cls, operation_names: tuple[str, ...]) -> "OperationFlowState":
+        """Return the reset operation state for one flow."""
+        return cls(
+            current_index=None,
+            rows={operation_name: OperationRowState() for operation_name in operation_names},
+        )
+
+    def row_state(self, operation_name: str) -> OperationRowState | None:
+        """Return one row state by operation name."""
+        return self.rows.get(operation_name)
+
+    def apply_event(
+        self,
+        operation_names: tuple[str, ...],
+        event: "RuntimeStepEvent",
+        *,
+        now: float,
+    ) -> tuple["OperationFlowState", int | None]:
+        """Return updated flow step state after one runtime step event."""
+        if event.step_name is None or event.step_name not in operation_names:
+            return self, None
+        current = self.row_state(event.step_name) or OperationRowState()
+        rows = dict(self.rows)
+        if event.status == "started":
+            rows[event.step_name] = current.started(now=now)
+            return type(self)(current_index=operation_names.index(event.step_name), rows=rows), None
+        if event.status == "success":
+            rows[event.step_name] = current.finished(status="success", elapsed_seconds=event.elapsed_seconds)
+            index = operation_names.index(event.step_name)
+            return type(self)(current_index=index, rows=rows), index
+        if event.status == "failed":
+            rows[event.step_name] = current.finished(status="failed", elapsed_seconds=event.elapsed_seconds)
+            return type(self)(current_index=self.current_index, rows=rows), None
+        return self, None
+
+    def normalized_completed(self) -> "OperationFlowState":
+        """Return a copy with completed success rows reset to idle."""
+        return type(self)(
+            current_index=self.current_index,
+            rows={name: row.normalized() for name, row in self.rows.items()},
+        )
+
+
+@dataclass(frozen=True)
+class OperationSessionState:
+    """Tracked step state for all loaded flows."""
+
+    flow_states: dict[str, OperationFlowState] = field(default_factory=dict)
+
+    @classmethod
+    def empty(cls) -> "OperationSessionState":
+        """Return the empty operation session state."""
+        return cls()
+
+    def state_for(self, flow_name: str) -> OperationFlowState | None:
+        """Return one flow operation state by flow name."""
+        return self.flow_states.get(flow_name)
+
+    def reset_flow(self, flow_name: str, operation_names: tuple[str, ...]) -> "OperationSessionState":
+        """Return a copy with one flow reset to idle operation state."""
+        states = dict(self.flow_states)
+        states[flow_name] = OperationFlowState.from_operation_names(operation_names)
+        return type(self)(flow_states=states)
+
+    def ensure_flow(self, flow_name: str, operation_names: tuple[str, ...]) -> "OperationSessionState":
+        """Return a copy guaranteed to contain one flow state."""
+        state = self.state_for(flow_name)
+        if state is None or not state.rows:
+            return self.reset_flow(flow_name, operation_names)
+        return self
+
+    def row_state(self, flow_name: str, operation_name: str) -> OperationRowState | None:
+        """Return one operation row state from the current session."""
+        state = self.state_for(flow_name)
+        if state is None:
+            return None
+        return state.row_state(operation_name)
+
+    def apply_event(
+        self,
+        flow_name: str,
+        operation_names: tuple[str, ...],
+        event: "RuntimeStepEvent",
+        *,
+        now: float,
+    ) -> tuple["OperationSessionState", int | None]:
+        """Return updated session state after one runtime step event."""
+        if event.step_name is None or event.step_name not in operation_names:
+            return self, None
+        ensured = self.ensure_flow(flow_name, operation_names)
+        flow_state = ensured.state_for(flow_name) or OperationFlowState.from_operation_names(operation_names)
+        updated_flow_state, flash_index = flow_state.apply_event(operation_names, event, now=now)
+        states = dict(ensured.flow_states)
+        states[flow_name] = updated_flow_state
+        return type(self)(flow_states=states), flash_index
+
+    def duration_text(self, flow_name: str, operation_name: str, *, now: float, formatter) -> str:
+        """Return one formatted duration string for the selected step row."""
+        row_state = self.row_state(flow_name, operation_name)
+        if row_state is None:
+            return ""
+        return row_state.duration_text(now=now, formatter=formatter)
+
+    def normalize_completed(self, flow_name: str) -> "OperationSessionState":
+        """Return a copy with completed success rows normalized for one flow."""
+        state = self.state_for(flow_name)
+        if state is None:
+            return self
+        states = dict(self.flow_states)
+        states[flow_name] = state.normalized_completed()
+        return type(self)(flow_states=states)
+
+    def reset(self) -> "OperationSessionState":
+        """Return the empty operation session state."""
+        return type(self).empty()
+
+
+__all__ = [
+    "OperationFlowState",
+    "OperationRowState",
+    "OperationSessionState",
+]

data_engine/domain/operator.py

@@ -0,0 +1,72 @@
+"""Domain models for top-level operator session state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from data_engine.domain.catalog import FlowCatalogState
+from data_engine.domain.operations import OperationSessionState
+from data_engine.domain.runtime import RuntimeSessionState, WorkspaceControlState
+from data_engine.domain.support import WorkspaceSupportState
+from data_engine.domain.workspace import WorkspaceSessionState
+
+if TYPE_CHECKING:
+    from data_engine.platform.workspace_models import WorkspacePaths
+
+
+@dataclass(frozen=True)
+class OperatorSessionState:
+    """Top-level operator state shared by one surface shell."""
+
+    workspace: WorkspaceSessionState
+    workspace_control: WorkspaceControlState
+    runtime: RuntimeSessionState
+    catalog: FlowCatalogState
+    operations: OperationSessionState
+    support: WorkspaceSupportState
+
+    @classmethod
+    def from_paths(
+        cls,
+        workspace_paths: "WorkspacePaths",
+        *,
+        override_root: Path | None = None,
+    ) -> "OperatorSessionState":
+        """Return the default operator state for one resolved workspace binding."""
+        return cls(
+            workspace=WorkspaceSessionState.from_paths(workspace_paths, override_root=override_root),
+            workspace_control=WorkspaceControlState.empty(),
+            runtime=RuntimeSessionState.empty(),
+            catalog=FlowCatalogState.empty(),
+            operations=OperationSessionState.empty(),
+            support=WorkspaceSupportState.empty(),
+        )
+
+    def with_workspace(self, workspace: WorkspaceSessionState) -> "OperatorSessionState":
+        """Return a copy with workspace session state replaced."""
+        return replace(self, workspace=workspace)
+
+    def with_workspace_control(self, workspace_control: WorkspaceControlState) -> "OperatorSessionState":
+        """Return a copy with workspace control state replaced."""
+        return replace(self, workspace_control=workspace_control)
+
+    def with_runtime(self, runtime: RuntimeSessionState) -> "OperatorSessionState":
+        """Return a copy with runtime session state replaced."""
+        return replace(self, runtime=runtime)
+
+    def with_catalog(self, catalog: FlowCatalogState) -> "OperatorSessionState":
+        """Return a copy with flow catalog state replaced."""
+        return replace(self, catalog=catalog)
+
+    def with_operations(self, operations: OperationSessionState) -> "OperatorSessionState":
+        """Return a copy with operation session state replaced."""
+        return replace(self, operations=operations)
+
+    def with_support(self, support: WorkspaceSupportState) -> "OperatorSessionState":
+        """Return a copy with support state replaced."""
+        return replace(self, support=support)
+
+
+__all__ = ["OperatorSessionState"]

data_engine/domain/runs.py

@@ -0,0 +1,155 @@
+"""Domain models for grouped flow-run state."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+from data_engine.domain.logs import FlowLogEntry
+
+RunKey = tuple[str, str]
+
+
+@dataclass(frozen=True)
+class RunStepState:
+    """One collapsed step state inside a grouped run."""
+
+    step_name: str
+    status: str
+    elapsed_seconds: float | None
+    entry: FlowLogEntry
+
+
+@dataclass(frozen=True)
+class FlowRunState:
+    """One grouped run plus its raw log history."""
+
+    key: RunKey
+    display_label: str
+    source_label: str
+    status: str
+    elapsed_seconds: float | None
+    summary_entry: FlowLogEntry | None
+    steps: tuple[RunStepState, ...]
+    entries: tuple[FlowLogEntry, ...]
+
+    @classmethod
+    def group_entries(cls, entries: tuple[FlowLogEntry, ...]) -> tuple["FlowRunState", ...]:
+        """Group flow log entries into one state object per run."""
+        if not entries:
+            return ()
+
+        run_index_by_id: dict[str, int] = {}
+        mutable_runs: list[dict[str, object]] = []
+
+        for entry in entries:
+            event = entry.event
+            if event is None or event.run_id is None:
+                continue
+
+            source_label = event.source_label
+            run_token = event.run_id
+            if event.step_name is None:
+                run_index = run_index_by_id.get(run_token)
+                if run_index is None:
+                    mutable_runs.append(
+                        {
+                            "key": (event.flow_name, run_token),
+                            "source_label": source_label,
+                            "status": event.status,
+                            "elapsed_seconds": event.elapsed_seconds,
+                            "summary_entry": entry,
+                            "steps": [],
+                            "entries": [entry],
+                        }
+                    )
+                    run_index_by_id[run_token] = len(mutable_runs) - 1
+                else:
+                    mutable_run = mutable_runs[run_index]
+                    if event.status not in {"success", "finished"} or mutable_run["status"] not in {"failed", "stopped"}:
+                        mutable_run["status"] = event.status
+                        mutable_run["summary_entry"] = entry
+                    mutable_run["elapsed_seconds"] = event.elapsed_seconds
+                    run_entries = mutable_run["entries"]
+                    assert isinstance(run_entries, list)
+                    run_entries.append(entry)
+                continue
+
+            run_index = run_index_by_id.get(run_token)
+            if run_index is None:
+                mutable_runs.append(
+                    {
+                        "key": (event.flow_name, run_token),
+                        "source_label": source_label,
+                        "status": "started",
+                        "elapsed_seconds": None,
+                        "summary_entry": None,
+                        "steps": [],
+                        "entries": [],
+                    }
+                )
+                run_index = len(mutable_runs) - 1
+                run_index_by_id[run_token] = run_index
+
+            mutable_run = mutable_runs[run_index]
+            steps = mutable_run["steps"]
+            assert isinstance(steps, list)
+            run_entries = mutable_run["entries"]
+            assert isinstance(run_entries, list)
+            run_entries.append(entry)
+            step_key = (event.flow_name, event.step_name, source_label)
+            step_state = RunStepState(
+                step_name=event.step_name,
+                status=event.status,
+                elapsed_seconds=event.elapsed_seconds,
+                entry=entry,
+            )
+            if event.status in {"success", "failed", "stopped"}:
+                for index in range(len(steps) - 1, -1, -1):
+                    candidate = steps[index]
+                    if (
+                        isinstance(candidate, RunStepState)
+                        and candidate.entry.event is not None
+                        and candidate.entry.event.step_name is not None
+                        and (
+                            candidate.entry.event.flow_name,
+                            candidate.entry.event.step_name,
+                            candidate.entry.event.source_label,
+                        )
+                        == step_key
+                        and candidate.entry.event.status == "started"
+                    ):
+                        steps[index] = step_state
+                        break
+                else:
+                    steps.append(step_state)
+            else:
+                steps.append(step_state)
+
+        return tuple(
+            cls(
+                key=run["key"],
+                display_label=cls._display_label_for_run(run),
+                source_label=run["source_label"],
+                status=run["status"],
+                elapsed_seconds=run["elapsed_seconds"],
+                summary_entry=run["summary_entry"],
+                steps=tuple(run["steps"]),
+                entries=tuple(run["entries"]),
+            )
+            for run in mutable_runs
+        )
+
+    @staticmethod
+    def _display_label_for_run(run: dict[str, object]) -> str:
+        summary_entry = run.get("summary_entry")
+        if isinstance(summary_entry, FlowLogEntry):
+            created_at = summary_entry.created_at_utc
+        else:
+            run_entries = run.get("entries")
+            first_entry = run_entries[0] if isinstance(run_entries, list) and run_entries else None
+            created_at = first_entry.created_at_utc if isinstance(first_entry, FlowLogEntry) else datetime.now(UTC)
+        return created_at.astimezone().strftime("%Y-%m-%d %I:%M:%S %p")
+
+
+__all__ = ["FlowRunState", "RunKey", "RunStepState"]

data_engine/domain/runtime.py

@@ -0,0 +1,279 @@
+"""Domain models for operator runtime and control state."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime, timedelta
+from dataclasses import dataclass, replace
+from enum import Enum
+from typing import TYPE_CHECKING, Iterable, Mapping
+
+from data_engine.domain.catalog import FlowCatalogLike
+from data_engine.domain.time import parse_utc_text
+
+CONTROL_CHECKPOINT_INTERVAL_SECONDS = 30.0
+CONTROL_STALE_AFTER_SECONDS = 90.0
+
+if TYPE_CHECKING:
+    from data_engine.hosts.daemon.manager import WorkspaceDaemonSnapshot
+
+
+class DaemonLifecyclePolicy(str, Enum):
+    """Lifecycle ownership policy for one daemon instance."""
+
+    EPHEMERAL = "ephemeral"
+    PERSISTENT = "persistent"
+
+    @classmethod
+    def coerce(cls, value: object) -> "DaemonLifecyclePolicy":
+        """Normalize a raw lifecycle-policy input."""
+        if isinstance(value, cls):
+            return value
+        text = str(value or "").strip().lower()
+        if not text:
+            return cls.PERSISTENT
+        return cls(text)
+
+
+@dataclass(frozen=True)
+class ManualRunState:
+    """One active manual run grouped by the owning flow group."""
+
+    group_name: str | None
+    flow_name: str
+
+
+@dataclass(frozen=True)
+class RuntimeSessionState:
+    """Runtime/control state shared by operator surfaces."""
+
+    workspace_owned: bool = True
+    leased_by_machine_id: str | None = None
+    runtime_active: bool = False
+    runtime_stopping: bool = False
+    active_runtime_flow_names: tuple[str, ...] = ()
+    manual_runs: tuple[ManualRunState, ...] = ()
+
+    @classmethod
+    def empty(cls) -> "RuntimeSessionState":
+        """Return the default idle local-control runtime state."""
+        return cls()
+
+    @classmethod
+    def from_daemon_snapshot(
+        cls,
+        snapshot: "WorkspaceDaemonSnapshot",
+        flow_cards: Iterable[FlowCatalogLike],
+    ) -> "RuntimeSessionState":
+        """Build one normalized session state from a daemon snapshot and loaded flows."""
+        cards = tuple(flow_cards)
+        cards_by_name = {card.name: card for card in cards}
+        manual_runs = tuple(
+            ManualRunState(group_name=card.group, flow_name=flow_name)
+            for flow_name in snapshot.manual_runs
+            if (card := cards_by_name.get(flow_name)) is not None
+        )
+        active_runtime_flow_names = (
+            tuple(card.name for card in cards if card.valid and card.mode in {"poll", "schedule"})
+            if snapshot.runtime_active
+            else ()
+        )
+        return cls(
+            workspace_owned=snapshot.workspace_owned,
+            leased_by_machine_id=snapshot.leased_by_machine_id,
+            runtime_active=snapshot.runtime_active,
+            runtime_stopping=snapshot.runtime_stopping,
+            active_runtime_flow_names=active_runtime_flow_names,
+            manual_runs=manual_runs,
+        )
+
+    @property
+    def control_available(self) -> bool:
+        """Return whether the current workstation may issue control actions."""
+        return self.workspace_owned or self.leased_by_machine_id is None
+
+    @property
+    def manual_run_active(self) -> bool:
+        """Return whether any manual runs are currently active."""
+        return bool(self.manual_runs)
+
+    @property
+    def has_active_work(self) -> bool:
+        """Return whether engine or manual work is currently active."""
+        return self.runtime_active or self.manual_run_active
+
+    @property
+    def active_manual_runs(self) -> dict[str | None, str]:
+        """Return active manual runs keyed by flow group."""
+        return {run.group_name: run.flow_name for run in self.manual_runs}
+
+    def manual_flow_name_for_group(self, group_name: str | None) -> str | None:
+        """Return the active flow name for one group, if any."""
+        for run in self.manual_runs:
+            if run.group_name == group_name:
+                return run.flow_name
+        return None
+
+    def is_group_active(self, group_name: str, flow_groups_by_name: Mapping[str, str]) -> bool:
+        """Return whether a flow group is active through a manual run or engine run."""
+        if self.manual_flow_name_for_group(group_name) is not None:
+            return True
+        if not self.runtime_active:
+            return False
+        return any(flow_groups_by_name.get(flow_name) == group_name for flow_name in self.active_runtime_flow_names)
+
+    def with_manual_runs_map(self, active_manual_runs: Mapping[str | None, str]) -> "RuntimeSessionState":
+        """Return a copy with active manual runs replaced from a mapping."""
+        return replace(
+            self,
+            manual_runs=tuple(
+                ManualRunState(group_name=group_name, flow_name=flow_name)
+                for group_name, flow_name in active_manual_runs.items()
+            ),
+        )
+
+    def without_manual_group(self, group_name: str | None) -> "RuntimeSessionState":
+        """Return a copy with one manual-run group removed."""
+        return replace(
+            self,
+            manual_runs=tuple(run for run in self.manual_runs if run.group_name != group_name),
+        )
+
+    def with_active_runtime_flow_names(self, flow_names: Iterable[str]) -> "RuntimeSessionState":
+        """Return a copy with active engine-owned flow names replaced."""
+        return replace(self, active_runtime_flow_names=tuple(flow_names))
+
+    def with_runtime_flags(self, *, active: bool, stopping: bool) -> "RuntimeSessionState":
+        """Return a copy with updated engine active/stopping flags."""
+        return replace(self, runtime_active=active, runtime_stopping=stopping)
+
+    def reset(self) -> "RuntimeSessionState":
+        """Return the default idle state for a fresh workspace binding."""
+        return type(self).empty()
+
+
+@dataclass(frozen=True)
+class DaemonStatusState:
+    """Last normalized daemon status for one operator surface."""
+
+    workspace_owned: bool = True
+    leased_by_machine_id: str | None = None
+    engine_active: bool = False
+    engine_stopping: bool = False
+    manual_run_names: tuple[str, ...] = ()
+    last_checkpoint_at_utc: str | None = None
+    source: str = "none"
+
+    @classmethod
+    def empty(cls) -> "DaemonStatusState":
+        """Return the default no-daemon/no-lease status."""
+        return cls()
+
+    @classmethod
+    def from_snapshot(cls, snapshot: "WorkspaceDaemonSnapshot") -> "DaemonStatusState":
+        """Build one daemon-status value object from a daemon snapshot."""
+        return cls(
+            workspace_owned=snapshot.workspace_owned,
+            leased_by_machine_id=snapshot.leased_by_machine_id,
+            engine_active=snapshot.runtime_active,
+            engine_stopping=snapshot.runtime_stopping,
+            manual_run_names=tuple(snapshot.manual_runs),
+            last_checkpoint_at_utc=snapshot.last_checkpoint_at_utc,
+            source=snapshot.source,
+        )
+
+    def as_runtime_session(self, flow_cards: Iterable[FlowCatalogLike]) -> RuntimeSessionState:
+        """Project daemon status into runtime session state using the current loaded flows."""
+        return RuntimeSessionState.from_daemon_snapshot(
+            type("SnapshotProxy", (), {
+                "workspace_owned": self.workspace_owned,
+                "leased_by_machine_id": self.leased_by_machine_id,
+                "runtime_active": self.engine_active,
+                "runtime_stopping": self.engine_stopping,
+                "manual_runs": self.manual_run_names,
+            })(),
+            flow_cards,
+        )
+
+@dataclass(frozen=True)
+class WorkspaceControlState:
+    """Workspace lease/control state derived from one daemon snapshot."""
+
+    daemon_status: DaemonStatusState
+    control_status_text: str | None
+    blocked_status_text: str
+    local_request_pending: bool = False
+    takeover_remaining_seconds: int | None = None
+
+    @classmethod
+    def empty(cls) -> "WorkspaceControlState":
+        """Return the default no-daemon/no-lease control state."""
+        return cls(
+            daemon_status=DaemonStatusState.empty(),
+            control_status_text=None,
+            blocked_status_text="Takeover available.",
+            local_request_pending=False,
+            takeover_remaining_seconds=None,
+        )
+
+    @classmethod
+    def from_snapshot(
+        cls,
+        snapshot: "WorkspaceDaemonSnapshot",
+        *,
+        daemon_live: bool,
+        local_machine_id: str,
+        control_request: Mapping[str, object] | None = None,
+        daemon_startup_in_progress: bool = False,
+        now_utc: datetime | None = None,
+    ) -> "WorkspaceControlState":
+        """Build one workspace control state from the latest daemon snapshot."""
+        status = DaemonStatusState.from_snapshot(snapshot)
+        local_request_pending = (
+            isinstance(control_request, Mapping)
+            and str(control_request.get("requester_machine_id", "")).strip() == local_machine_id
+        )
+        checkpoint_at = parse_utc_text(status.last_checkpoint_at_utc) if status.last_checkpoint_at_utc else None
+        now = now_utc or datetime.now(UTC)
+
+        control_status_text: str | None
+        takeover_remaining_seconds: int | None = None
+
+        if status.source == "none":
+            control_status_text = None
+        elif status.workspace_owned:
+            if daemon_startup_in_progress:
+                control_status_text = "Trying to restore local control..."
+            elif checkpoint_at is None:
+                control_status_text = "This Workstation has control"
+            else:
+                age = max((now - checkpoint_at).total_seconds(), 0.0)
+                if age >= CONTROL_CHECKPOINT_INTERVAL_SECONDS and not daemon_live:
+                    control_status_text = "Local engine is not responding"
+                else:
+                    control_status_text = "This Workstation has control"
+        else:
+            owner = status.leased_by_machine_id or "Another machine"
+            if local_request_pending:
+                control_status_text = f"Control requested from {owner}"
+            elif checkpoint_at is None:
+                control_status_text = f"{owner} has control"
+            else:
+                stale_at = checkpoint_at + timedelta(seconds=CONTROL_STALE_AFTER_SECONDS)
+                takeover_remaining_seconds = max(int((stale_at - now).total_seconds()), 0)
+                if takeover_remaining_seconds <= 0:
+                    control_status_text = "Takeover available"
+                else:
+                    control_status_text = f"{owner} has control · takeover available in {takeover_remaining_seconds}s"
+
+        if status.leased_by_machine_id is None:
+            blocked_status_text = "Takeover available."
+        else:
+            blocked_status_text = f"{status.leased_by_machine_id} currently has control of this workspace."
+
+        return cls(
+            daemon_status=status,
+            control_status_text=control_status_text,
+            blocked_status_text=blocked_status_text,
+            local_request_pending=local_request_pending,
+            takeover_remaining_seconds=takeover_remaining_seconds,
+        )