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

data_engine/application/runtime.py

@@ -0,0 +1,449 @@
+"""Host-agnostic runtime and daemon-control use cases."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Any
+from collections.abc import Iterable
+
+from data_engine.authoring.model import FlowStoppedError
+from data_engine.domain import (
+    DaemonLifecyclePolicy,
+    DaemonStatusState,
+    FlowLogEntry,
+    OperationSessionState,
+    RuntimeSessionState,
+    WorkspaceControlState,
+    default_flow_state,
+)
+from data_engine.domain.catalog import FlowCatalogLike
+from data_engine.hosts.daemon.manager import WorkspaceDaemonManager
+from data_engine.platform.workspace_models import WorkspacePaths, authored_workspace_is_available
+from data_engine.services import DaemonService, DaemonStateService, SharedStateService
+
+
+@dataclass(frozen=True)
+class DaemonCommandResult:
+    """Normalized outcome of one daemon command request."""
+
+    ok: bool
+    error: str = ""
+    payload: dict[str, Any] | None = None
+
+
+@dataclass(frozen=True)
+class RuntimeSyncState:
+    """Normalized daemon/runtime sync state shared by hosts."""
+
+    daemon_status: DaemonStatusState
+    workspace_control_state: WorkspaceControlState
+    runtime_session: RuntimeSessionState
+    snapshot_source: str
+    snapshot: object
+
+
+@dataclass(frozen=True)
+class RuntimeLogMessage:
+    """One host-neutral log line emitted by a runtime completion path."""
+
+    text: str
+    flow_name: str | None = None
+
+
+@dataclass(frozen=True)
+class RuntimeSnapshotPresentation:
+    """Normalized runtime snapshot state rebuilt from persisted log history."""
+
+    operation_tracker: OperationSessionState
+    flow_states: dict[str, str]
+
+    def signature_for(self, runtime_session: RuntimeSessionState) -> tuple[object, ...]:
+        """Return a stable signature for render-diff decisions."""
+        return (
+            tuple(sorted(self.flow_states.items())),
+            tuple(sorted(runtime_session.active_runtime_flow_names)),
+            tuple(sorted(runtime_session.active_manual_runs.items())),
+            runtime_session.workspace_owned,
+            runtime_session.leased_by_machine_id,
+        )
+
+
+@dataclass(frozen=True)
+class FlowStateRefreshPlan:
+    """Normalized host-agnostic flow-state refresh plan."""
+
+    flow_states: dict[str, str]
+    changed_flow_names: frozenset[str]
+    signature: tuple[object, ...]
+
+    @property
+    def states_changed(self) -> bool:
+        """Return whether any flow-state value changed."""
+        return bool(self.changed_flow_names)
+
+
+@dataclass(frozen=True)
+class ManualRunCompletion:
+    """Normalized manual-run completion state for operator surfaces."""
+
+    runtime_session: RuntimeSessionState
+    state_updates: dict[str, str]
+    log_messages: tuple[RuntimeLogMessage, ...]
+    capture_results: bool = False
+    normalize_operations: bool = False
+    render_durations: bool = False
+    show_error_text: str | None = None
+
+
+@dataclass(frozen=True)
+class EngineRunCompletion:
+    """Normalized engine-run completion state for operator surfaces."""
+
+    runtime_session: RuntimeSessionState
+    state_updates: dict[str, str]
+    failed_flow_names: tuple[str, ...] = ()
+    log_messages: tuple[RuntimeLogMessage, ...] = ()
+
+
+class RuntimeApplication:
+    """Own host-neutral daemon sync and runtime command use cases."""
+
+    def __init__(
+        self,
+        *,
+        daemon_service: DaemonService,
+        daemon_state_service: DaemonStateService,
+        shared_state_service: SharedStateService,
+        daemon_lifecycle_policy: DaemonLifecyclePolicy = DaemonLifecyclePolicy.EPHEMERAL,
+    ) -> None:
+        self.daemon_service = daemon_service
+        self.daemon_state_service = daemon_state_service
+        self.shared_state_service = shared_state_service
+        self.daemon_lifecycle_policy = daemon_lifecycle_policy
+
+    def sync_state(
+        self,
+        *,
+        paths: WorkspacePaths,
+        daemon_manager: WorkspaceDaemonManager,
+        flow_cards,
+        runtime_ledger,
+        daemon_startup_in_progress: bool = False,
+    ) -> RuntimeSyncState:
+        """Return normalized daemon/runtime state for one host surface."""
+        snapshot = self.daemon_state_service.sync(daemon_manager)
+        if snapshot.source == "lease":
+            self.shared_state_service.hydrate_local_runtime(paths, runtime_ledger)
+        daemon_status = DaemonStatusState.from_snapshot(snapshot)
+        return RuntimeSyncState(
+            daemon_status=daemon_status,
+            workspace_control_state=self.daemon_state_service.control_state(
+                daemon_manager,
+                snapshot,
+                daemon_startup_in_progress=daemon_startup_in_progress,
+            ),
+            runtime_session=RuntimeSessionState.from_daemon_snapshot(snapshot, flow_cards),
+            snapshot_source=snapshot.source,
+            snapshot=snapshot,
+        )
+
+    def build_runtime_snapshot(
+        self,
+        *,
+        flow_cards: Iterable[FlowCatalogLike],
+        log_entries: Iterable[FlowLogEntry],
+        runtime_session: RuntimeSessionState,
+        now: float,
+    ) -> RuntimeSnapshotPresentation:
+        """Return normalized runtime flow state rebuilt from catalog metadata and log history."""
+        tracker = OperationSessionState.empty()
+        states: dict[str, str] = {}
+        cards_by_name: dict[str, FlowCatalogLike] = {}
+        for card in flow_cards:
+            cards_by_name[card.name] = card
+            tracker = tracker.ensure_flow(card.name, card.operation_items)
+            states[card.name] = card.state if card.valid else "invalid"
+        for entry in log_entries:
+            event = entry.event
+            if event is None or event.flow_name not in cards_by_name:
+                continue
+            card = cards_by_name[event.flow_name]
+            if event.step_name is None:
+                if event.status == "failed":
+                    states[event.flow_name] = "failed"
+                elif event.status in {"started", "success", "stopped"}:
+                    states[event.flow_name] = default_flow_state(card.mode)
+                continue
+            age_seconds = max((datetime.now(UTC) - entry.created_at_utc).total_seconds(), 0.0)
+            tracker, _ = tracker.apply_event(
+                event.flow_name,
+                card.operation_items,
+                event,
+                now=now - age_seconds,
+            )
+        for flow_name in list(states):
+            tracker = tracker.normalize_completed(flow_name)
+        for flow_name in runtime_session.active_runtime_flow_names:
+            card = cards_by_name.get(flow_name)
+            if card is None or states.get(flow_name) == "failed":
+                continue
+            states[flow_name] = (
+                "stopping runtime"
+                if runtime_session.runtime_stopping
+                else ("polling" if card.mode == "poll" else "scheduled")
+            )
+        for flow_name in runtime_session.active_manual_runs.values():
+            if flow_name in states and states.get(flow_name) != "failed":
+                states[flow_name] = "running"
+        return RuntimeSnapshotPresentation(
+            operation_tracker=tracker,
+            flow_states=states,
+        )
+
+    def plan_flow_state_refresh(
+        self,
+        *,
+        previous_states: dict[str, str] | None,
+        next_states: dict[str, str],
+        runtime_session: RuntimeSessionState,
+    ) -> FlowStateRefreshPlan:
+        """Return one shared diff/signature plan for flow-state refresh decisions."""
+        previous = previous_states or {}
+        changed_flow_names = frozenset(
+            flow_name
+            for flow_name in set(previous) | set(next_states)
+            if previous.get(flow_name) != next_states.get(flow_name)
+        )
+        signature = (
+            tuple(sorted(next_states.items())),
+            tuple(sorted(runtime_session.active_runtime_flow_names)),
+            tuple(sorted(runtime_session.active_manual_runs.items())),
+            runtime_session.workspace_owned,
+            runtime_session.leased_by_machine_id,
+        )
+        return FlowStateRefreshPlan(
+            flow_states=dict(next_states),
+            changed_flow_names=changed_flow_names,
+            signature=signature,
+        )
+
+    def run_flow(self, paths: WorkspacePaths, *, name: str, wait: bool = False, timeout: float = 2.0) -> DaemonCommandResult:
+        """Request one manual flow run through the daemon."""
+        if not authored_workspace_is_available(paths):
+            return DaemonCommandResult(ok=False, error="Workspace root is no longer available.")
+        return self._spawn_and_request(
+            paths,
+            {"command": "run_flow", "name": name, "wait": wait},
+            timeout=timeout,
+        )
+
+    def start_engine(self, paths: WorkspacePaths, *, timeout: float = 2.0) -> DaemonCommandResult:
+        """Request automated runtime start through the daemon."""
+        if not authored_workspace_is_available(paths):
+            return DaemonCommandResult(ok=False, error="Workspace root is no longer available.")
+        return self._spawn_and_request(paths, {"command": "start_engine"}, timeout=timeout)
+
+    def refresh_flows(self, paths: WorkspacePaths, *, timeout: float = 5.0) -> DaemonCommandResult:
+        """Request one daemon-side flow refresh through the daemon."""
+        return self._spawn_and_request(paths, {"command": "refresh_flows"}, timeout=timeout)
+
+    def stop_engine(self, paths: WorkspacePaths, *, timeout: float = 2.0) -> DaemonCommandResult:
+        """Request automated runtime stop through the daemon."""
+        return self._request(paths, {"command": "stop_engine"}, timeout=timeout)
+
+    def stop_flow(self, paths: WorkspacePaths, *, name: str, timeout: float = 2.0) -> DaemonCommandResult:
+        """Request one manual flow stop through the daemon."""
+        return self._request(paths, {"command": "stop_flow", "name": name}, timeout=timeout)
+
+    def daemon_status(self, paths: WorkspacePaths, *, timeout: float = 0.0) -> DaemonCommandResult:
+        """Request raw daemon status for host/CLI inspection."""
+        return self._request(paths, {"command": "daemon_status"}, timeout=timeout)
+
+    def shutdown_daemon(self, paths: WorkspacePaths, *, timeout: float = 0.0) -> DaemonCommandResult:
+        """Request daemon shutdown for one workspace."""
+        return self._request(paths, {"command": "shutdown_daemon"}, timeout=timeout)
+
+    def force_shutdown_daemon(self, paths: WorkspacePaths, *, timeout: float = 0.5) -> DaemonCommandResult:
+        """Force-stop the local daemon for one workspace."""
+        try:
+            self.daemon_service.force_shutdown(paths, timeout=timeout)
+        except self.daemon_service.client_error_type as exc:
+            return DaemonCommandResult(
+                ok=False,
+                error=_daemon_command_error_text({"command": "force_shutdown_daemon"}, exc),
+            )
+        return DaemonCommandResult(ok=True)
+
+    def spawn_daemon(self, paths: WorkspacePaths) -> DaemonCommandResult:
+        """Start the local daemon using the application lifecycle policy."""
+        try:
+            self.daemon_service.spawn(
+                paths,
+                lifecycle_policy=self.daemon_lifecycle_policy,
+            )
+        except self.daemon_service.client_error_type as exc:
+            return DaemonCommandResult(ok=False, error=str(exc))
+        return DaemonCommandResult(ok=True)
+
+    def complete_manual_run(
+        self,
+        *,
+        runtime_session: RuntimeSessionState,
+        flow_name: str,
+        group_name: str | None,
+        flow_mode: str,
+        results: object,
+        error: object,
+        stop_requested: bool,
+    ) -> ManualRunCompletion:
+        """Return normalized state/log outcomes for one completed manual run."""
+        next_runtime = runtime_session.without_manual_group(group_name)
+        default_state = _default_state_for_mode(flow_mode)
+        if isinstance(error, Exception):
+            error_text = _error_text(error)
+            if isinstance(error, FlowStoppedError) or stop_requested:
+                return ManualRunCompletion(
+                    runtime_session=next_runtime,
+                    state_updates={flow_name: default_state},
+                    log_messages=(RuntimeLogMessage(f"Flow stopped: {flow_name}", flow_name=flow_name),),
+                )
+            return ManualRunCompletion(
+                runtime_session=next_runtime,
+                state_updates={flow_name: "failed"},
+                log_messages=(RuntimeLogMessage(f"Flow failed: {flow_name}: {error_text}", flow_name=flow_name),),
+                show_error_text=f"{flow_name} failed.\n\n{error_text}" if flow_mode == "manual" else None,
+            )
+        result_count = len(results or [])
+        return ManualRunCompletion(
+            runtime_session=next_runtime,
+            state_updates={flow_name: default_state},
+            log_messages=(RuntimeLogMessage(f"Flow finished: {flow_name} with {result_count} result(s)", flow_name=flow_name),),
+            capture_results=True,
+            normalize_operations=True,
+            render_durations=True,
+        )
+
+    def complete_engine_run(
+        self,
+        *,
+        runtime_session: RuntimeSessionState,
+        flow_names: tuple[str, ...],
+        flow_modes_by_name: dict[str, str],
+        error: object,
+        runtime_stop_requested: bool,
+        flow_stop_requested: bool,
+    ) -> EngineRunCompletion:
+        """Return normalized state/log outcomes for one completed engine run."""
+        next_runtime = runtime_session.with_runtime_flags(active=False, stopping=False).with_active_runtime_flow_names(())
+        default_states = {flow_name: _default_state_for_mode(flow_modes_by_name[flow_name]) for flow_name in flow_names}
+        if isinstance(error, Exception):
+            if isinstance(error, FlowStoppedError) or runtime_stop_requested or flow_stop_requested:
+                return EngineRunCompletion(
+                    runtime_session=next_runtime,
+                    state_updates=default_states,
+                    log_messages=tuple(RuntimeLogMessage("Runtime flow stop.", flow_name=flow_name) for flow_name in flow_names),
+                )
+            return EngineRunCompletion(
+                runtime_session=next_runtime,
+                state_updates=default_states,
+                failed_flow_names=flow_names,
+                log_messages=tuple(
+                    RuntimeLogMessage(f"Runtime failed: {error}", flow_name=flow_name)
+                    for flow_name in flow_names
+                ),
+            )
+        return EngineRunCompletion(
+            runtime_session=next_runtime,
+            state_updates=default_states,
+            log_messages=tuple(RuntimeLogMessage("Runtime flow finish.", flow_name=flow_name) for flow_name in flow_names),
+        )
+
+    def _spawn_and_request(
+        self,
+        paths: WorkspacePaths,
+        payload: dict[str, Any],
+        *,
+        timeout: float = 0.0,
+    ) -> DaemonCommandResult:
+        spawn_result = self.spawn_daemon(paths)
+        if not spawn_result.ok:
+            return DaemonCommandResult(
+                ok=False,
+                error=_daemon_command_error_text(payload, spawn_result.error),
+            )
+        return self._request(paths, payload, timeout=timeout)
+
+    def _request(
+        self,
+        paths: WorkspacePaths,
+        payload: dict[str, Any],
+        *,
+        timeout: float = 0.0,
+    ) -> DaemonCommandResult:
+        try:
+            response = self.daemon_service.request(paths, payload, timeout=timeout)
+        except self.daemon_service.client_error_type as exc:
+            return DaemonCommandResult(ok=False, error=_daemon_command_error_text(payload, exc))
+        if not response.get("ok"):
+            return DaemonCommandResult(
+                ok=False,
+                error=_daemon_command_error_text(payload, response.get("error")),
+                payload=response,
+            )
+        return DaemonCommandResult(ok=True, payload=response)
+
+
+def _daemon_command_error_text(payload: dict[str, Any], detail: object | None) -> str:
+    """Return a verbose daemon-command failure message with any available detail."""
+    text = str(detail).strip() if detail is not None else ""
+    if text:
+        return text
+    return f"Failed to {_daemon_command_action(payload.get('command'))}. The daemon returned no additional detail."
+
+
+def _daemon_command_action(command: object) -> str:
+    if command == "run_flow":
+        return "run the selected flow"
+    if command == "start_engine":
+        return "start the automated engine"
+    if command == "refresh_flows":
+        return "refresh flow definitions"
+    if command == "stop_engine":
+        return "stop the engine"
+    if command == "stop_flow":
+        return "stop the selected flow"
+    if command == "daemon_status":
+        return "retrieve daemon status"
+    if command == "shutdown_daemon":
+        return "shut down the daemon"
+    if command == "force_shutdown_daemon":
+        return "force-stop the daemon"
+    return "complete the requested daemon command"
+
+
+def _default_state_for_mode(mode: str | None) -> str:
+    if mode == "poll":
+        return "poll ready"
+    if mode == "schedule":
+        return "schedule ready"
+    return "manual"
+
+
+def _error_text(error: Exception) -> str:
+    """Return a non-blank user-facing error detail string."""
+    detail = str(error).strip()
+    if detail:
+        return detail
+    return type(error).__name__
+
+
+__all__ = [
+    "DaemonCommandResult",
+    "EngineRunCompletion",
+    "ManualRunCompletion",
+    "RuntimeApplication",
+    "RuntimeLogMessage",
+    "RuntimeSnapshotPresentation",
+    "RuntimeSyncState",
+]

data_engine/application/workspace.py

@@ -0,0 +1,62 @@
+"""Host-agnostic workspace session use cases."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from data_engine.domain import OperatorSessionState, WorkspaceSessionState
+from data_engine.platform.workspace_models import WorkspacePaths
+from data_engine.services import WorkspaceService
+
+
+@dataclass(frozen=True)
+class WorkspaceBinding:
+    """Normalized workspace/session binding for one resolved workspace target."""
+
+    operator_session: OperatorSessionState
+    workspace_session: WorkspaceSessionState
+
+
+class WorkspaceSessionApplication:
+    """Own workspace discovery and session-state derivation for hosts."""
+
+    def __init__(self, *, workspace_service: WorkspaceService) -> None:
+        self.workspace_service = workspace_service
+
+    def refresh_session(
+        self,
+        *,
+        workspace_paths: WorkspacePaths,
+        override_root: Path | None,
+    ) -> WorkspaceSessionState:
+        """Return workspace session state rebound to paths plus current discovery."""
+        discovered = self.workspace_service.discover(
+            app_root=workspace_paths.app_root,
+            workspace_collection_root=override_root,
+        )
+        return WorkspaceSessionState.from_paths(
+            workspace_paths,
+            override_root=override_root,
+            discovered_workspace_ids=(item.workspace_id for item in discovered),
+        )
+
+    def bind_workspace(
+        self,
+        *,
+        workspace_paths: WorkspacePaths,
+        override_root: Path | None,
+    ) -> WorkspaceBinding:
+        """Return a fresh operator/session binding for one resolved workspace target."""
+        workspace_session = self.refresh_session(
+            workspace_paths=workspace_paths,
+            override_root=override_root,
+        )
+        operator_session = OperatorSessionState.from_paths(
+            workspace_paths,
+            override_root=override_root,
+        ).with_workspace(workspace_session)
+        return WorkspaceBinding(
+            operator_session=operator_session,
+            workspace_session=workspace_session,
+        )

data_engine/authoring/__init__.py

@@ -0,0 +1,14 @@
+"""Authoring DSL and core flow model primitives."""
+
+from __future__ import annotations
+
+from importlib import import_module
+
+__all__ = ["Batch", "FileRef", "Flow", "FlowContext", "discover_flows", "load_flow", "run"]
+
+
+def __getattr__(name: str):
+    if name not in __all__:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    builder = import_module("data_engine.authoring.builder")
+    return getattr(builder, name)

data_engine/authoring/builder.py

@@ -0,0 +1,31 @@
+"""Public facade for the authoring DSL and runtime entrypoints."""
+
+from data_engine.authoring.execution import _FlowRuntime
+from data_engine.authoring.execution import _GroupedFlowRuntime
+from data_engine.authoring.flow import Flow
+from data_engine.authoring.flow import discover_flows
+from data_engine.authoring.flow import load_flow
+from data_engine.authoring.flow import run
+from data_engine.authoring.helpers import _title_case_words
+from data_engine.authoring.primitives import Batch
+from data_engine.authoring.primitives import FileRef
+from data_engine.authoring.primitives import FlowContext
+from data_engine.authoring.primitives import MirrorContext
+from data_engine.authoring.primitives import SourceContext
+from data_engine.authoring.primitives import collect_files
+
+__all__ = [
+    "Batch",
+    "FileRef",
+    "Flow",
+    "FlowContext",
+    "MirrorContext",
+    "SourceContext",
+    "_FlowRuntime",
+    "_GroupedFlowRuntime",
+    "_title_case_words",
+    "collect_files",
+    "discover_flows",
+    "load_flow",
+    "run",
+]

data_engine/authoring/execution/__init__.py

@@ -0,0 +1,6 @@
+"""Runtime execution internals for authored flows."""
+
+from data_engine.authoring.execution.app import _GroupedFlowRuntime
+from data_engine.authoring.execution.app import _FlowRuntime
+
+__all__ = ["_FlowRuntime", "_GroupedFlowRuntime"]

data_engine/authoring/execution/app.py

@@ -0,0 +1,6 @@
+"""Facade for authored flow runtime execution internals."""
+
+from data_engine.authoring.execution.grouped import _GroupedFlowRuntime
+from data_engine.authoring.execution.single import _FlowRuntime
+
+__all__ = ["_FlowRuntime", "_GroupedFlowRuntime"]

data_engine/authoring/execution/context.py

@@ -0,0 +1,82 @@
+"""Runtime context building helpers for authored flows."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+from pathlib import Path
+from uuid import uuid4
+
+from data_engine.authoring.primitives import FlowContext, MirrorContext, SourceContext, WatchSpec, WorkspaceConfigContext
+from data_engine.domain.source_state import SourceSignature
+from data_engine.domain.time import utcnow_text
+
+
+@dataclass(frozen=True)
+class _QueuedJob:
+    """One queued runtime job for a flow and an optional concrete source file."""
+
+    flow: "Flow"
+    source_path: Path | None
+    batch_signatures: tuple[SourceSignature, ...] = ()
+
+
+class RuntimeContextBuilder:
+    """Build runtime flow contexts for concrete or root-level executions."""
+
+    @staticmethod
+    def _source_key_text(*, source_path: Path | None, relative_path: Path | None) -> str | None:
+        if relative_path is not None:
+            return relative_path.as_posix()
+        if source_path is not None:
+            return source_path.as_posix()
+        return None
+
+    @classmethod
+    def _source_file_hash(cls, *, source_path: Path | None, relative_path: Path | None) -> str | None:
+        source_key = cls._source_key_text(source_path=source_path, relative_path=relative_path)
+        if source_key is None:
+            return None
+        return hashlib.sha1(source_key.encode("utf-8")).hexdigest()
+
+    def new_run_id(self) -> str:
+        return uuid4().hex
+
+    def build(self, flow: "Flow", source_path: Path | None, *, run_id: str) -> FlowContext:
+        metadata: dict[str, object] = {"started_at_utc": utcnow_text(), "run_id": run_id, "step_outputs": {}}
+        context = FlowContext(
+            flow_name=flow.name,
+            group=flow.group,
+            metadata=metadata,
+            config=WorkspaceConfigContext(workspace_root=flow._workspace_root),
+        )
+        source_root: Path | None = None
+        resolved_source_path: Path | None = None
+        relative_path: Path | None = None
+        trigger = flow.trigger
+        if isinstance(trigger, WatchSpec) and trigger.source is not None:
+            if trigger.source.exists() and trigger.source.is_dir():
+                source_root = trigger.source
+                if source_path is not None:
+                    resolved_source_path = source_path
+                    relative_path = source_path.relative_to(trigger.source)
+            elif trigger.source.exists() and trigger.source.is_file():
+                resolved_source = source_path if source_path is not None else trigger.source
+                resolved_source_path = resolved_source
+                source_root = trigger.source.parent
+                relative_path = Path(resolved_source.name)
+        if source_root is not None:
+            context.source = SourceContext(root=source_root, path=resolved_source_path, relative_path=relative_path)
+        file_hash = self._source_file_hash(source_path=resolved_source_path, relative_path=relative_path)
+        if file_hash is not None:
+            context.metadata["file_hash"] = file_hash
+        if flow.mirror_spec is not None:
+            context.mirror = MirrorContext(
+                root=flow.mirror_spec.root,
+                source_path=context.source.path if context.source is not None else None,
+                relative_path=context.source.relative_path if context.source is not None else None,
+            )
+        return context
+
+
+__all__ = ["RuntimeContextBuilder", "_QueuedJob"]