optio-core 0.1.0__py3-none-any.whl

optio_core/__init__.py

@@ -0,0 +1,50 @@
+"""Optio — reusable async process management library."""
+
+from optio_core.models import (
+    TaskInstance, TaskInstanceCore, ChildResult, LaunchBlocked,
+    LaunchOutcome, CancelOutcome, DismissOutcome,
+)
+from optio_core.lifecycle import Optio
+
+_instance = Optio()
+
+init = _instance.init
+run = _instance.run
+shutdown = _instance.shutdown
+adhoc_define = _instance.adhoc_define
+adhoc_delete = _instance.adhoc_delete
+launch = _instance.launch
+launch_and_wait = _instance.launch_and_wait
+cancel = _instance.cancel
+dismiss = _instance.dismiss
+resync = _instance.resync
+get_process = _instance.get_process
+list_processes = _instance.list_processes
+block_launches = _instance.block_launches
+unblock_launches = _instance.unblock_launches
+group_cancel = _instance.group_cancel
+group_cancel_and_wait = _instance.group_cancel_and_wait
+
+__all__ = [
+    "TaskInstance", "TaskInstanceCore", "ChildResult", "LaunchBlocked",
+    "LaunchOutcome", "CancelOutcome", "DismissOutcome",
+    "init", "run", "shutdown",
+    "adhoc_define", "adhoc_delete",
+    "launch", "launch_and_wait", "cancel", "dismiss", "resync",
+    "get_process", "list_processes",
+    "block_launches", "unblock_launches",
+    "group_cancel", "group_cancel_and_wait",
+    "rpc_server",
+]
+
+
+def __getattr__(name: str):
+    """Module-level attribute lookup for runtime-populated attributes.
+
+    `rpc_server` is set on the singleton _instance during init(); a normal
+    `rpc_server = _instance.rpc_server` binding at module import time would
+    capture None forever. PEP 562 __getattr__ forwards reads on access.
+    """
+    if name == "rpc_server":
+        return _instance.rpc_server
+    raise AttributeError(f"module 'optio_core' has no attribute {name!r}")

optio_core/_engine_service.py

@@ -0,0 +1,161 @@
+"""Clamator RPC implementation for the optio-engine contract."""
+
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING
+
+from bson import ObjectId
+
+from optio_core._generated.optio_engine import (
+    OptioEngineService as OptioEngineServiceBase,
+    LaunchParams, LaunchResult,
+    CancelParams, CancelResult,
+    DismissParams, DismissResult,
+    GroupCancelParams, GroupCancelResult,
+    GroupCancelAndWaitParams, GroupCancelAndWaitResult,
+    BlockLaunchesParams, BlockLaunchesResult,
+    UnblockLaunchesParams, UnblockLaunchesResult,
+    ResyncParams,
+)
+
+if TYPE_CHECKING:
+    from optio_core.lifecycle import Optio
+
+
+_UTC = datetime.timezone.utc
+
+# Allowed top-level keys in the Process wire model (by-alias names).
+_PROCESS_WIRE_KEYS = frozenset({
+    "_id", "processId", "name", "params", "metadata", "parentId", "rootId",
+    "depth", "order", "cancellable", "special", "warning", "description",
+    "status", "progress", "log", "uiWidget", "widgetData", "supportsResume",
+    "hasSavedState", "createdAt",
+})
+
+
+def _fix_value(v: object) -> object:
+    """Recursively normalize a Mongo value to a wire-safe value."""
+    if isinstance(v, ObjectId):
+        return str(v)
+    if isinstance(v, datetime.datetime) and v.tzinfo is None:
+        return v.replace(tzinfo=_UTC)
+    if isinstance(v, dict):
+        return {k2: _fix_value(v2) for k2, v2 in v.items()}
+    if isinstance(v, list):
+        return [_fix_value(item) for item in v]
+    return v
+
+
+def _to_process_dict(doc: dict) -> dict:
+    """Render a Mongo process doc as the wire-shape Process payload.
+
+    Returns a dict that LaunchResult1.process / CancelResult1.process /
+    DismissResult1.process etc. can validate. Generated Process model uses
+    by-alias field names (e.g. _id, processId, supportsResume).
+
+    Strips fields unknown to the contract (e.g. adhoc, ephemeral, ttlSeconds
+    stored by the scheduler), stringifies ObjectIds, and makes naive datetimes
+    UTC-aware so Pydantic AwareDatetime validation passes.
+    """
+    out = {
+        k: _fix_value(v)
+        for k, v in doc.items()
+        if k in _PROCESS_WIRE_KEYS
+    }
+    return out
+
+
+class OptioEngineService(OptioEngineServiceBase):
+    """Concrete OptioEngineService backing the clamator optio-engine contract."""
+
+    def __init__(self, optio: "Optio") -> None:
+        self._optio = optio
+
+    # --------------------------------------------------------------- launch
+    async def launch(self, params: LaunchParams) -> LaunchResult:
+        outcome = await self._optio.launch(
+            params.process_id, resume=bool(params.resume),
+        )
+        if not outcome.ok:
+            return LaunchResult.model_validate(
+                {"ok": False, "reason": outcome.reason}
+            )
+        return LaunchResult.model_validate(
+            {"ok": True, "process": _to_process_dict(outcome.proc)}
+        )
+
+    # --------------------------------------------------------------- cancel
+    async def cancel(self, params: CancelParams) -> CancelResult:
+        outcome = await self._optio.cancel(params.process_id)
+        if not outcome.ok:
+            return CancelResult.model_validate(
+                {"ok": False, "reason": outcome.reason}
+            )
+        return CancelResult.model_validate(
+            {"ok": True, "process": _to_process_dict(outcome.proc)}
+        )
+
+    # --------------------------------------------------------------- dismiss
+    async def dismiss(self, params: DismissParams) -> DismissResult:
+        outcome = await self._optio.dismiss(params.process_id)
+        if not outcome.ok:
+            return DismissResult.model_validate(
+                {"ok": False, "reason": outcome.reason}
+            )
+        return DismissResult.model_validate(
+            {"ok": True, "process": _to_process_dict(outcome.proc)}
+        )
+
+    # --------------------------------------------------------------- resync
+    async def resync(self, params: ResyncParams) -> None:
+        await self._optio.resync(
+            clean=bool(params.clean),
+            metadata_filter=params.metadata_filter,
+        )
+
+    # --------------------------------------------------------------- group_cancel / group_cancel_and_wait
+    async def group_cancel(self, params: GroupCancelParams) -> GroupCancelResult:
+        if params.persist and not params.block_new_launches:
+            return GroupCancelResult.model_validate(
+                {"ok": False, "reason": "invalid-persist-without-block"}
+            )
+        count = await self._optio.group_cancel(
+            metadata_filter=params.metadata_filter,
+            block_new_launches=bool(params.block_new_launches),
+            persist=bool(params.persist),
+            reason=params.reason,
+        )
+        return GroupCancelResult.model_validate({"ok": True, "cancelledCount": count})
+
+    async def group_cancel_and_wait(
+        self, params: GroupCancelAndWaitParams
+    ) -> GroupCancelAndWaitResult:
+        if params.persist and not params.block_new_launches:
+            return GroupCancelAndWaitResult.model_validate(
+                {"ok": False, "reason": "invalid-persist-without-block"}
+            )
+        count = await self._optio.group_cancel_and_wait(
+            metadata_filter=params.metadata_filter,
+            block_new_launches=bool(params.block_new_launches),
+            persist=bool(params.persist),
+            reason=params.reason,
+        )
+        return GroupCancelAndWaitResult.model_validate({"ok": True, "cancelledCount": count})
+
+    # --------------------------------------------------------------- block_launches / unblock_launches
+    async def block_launches(self, params: BlockLaunchesParams) -> BlockLaunchesResult:
+        from optio_core import _launch_block_store as _lb_store
+        coll = _lb_store.collection(
+            self._optio._config.mongo_db,
+            self._optio._config.prefix,
+        )
+        await _lb_store.upsert_block(coll, params.launch_filter, params.reason)
+        await self._optio._load_persisted_blocks()
+        return BlockLaunchesResult.model_validate({"ok": True})
+
+    async def unblock_launches(
+        self, params: UnblockLaunchesParams
+    ) -> UnblockLaunchesResult:
+        removed = await self._optio.unblock_launches(params.launch_filter)
+        return UnblockLaunchesResult(removed=removed)

optio_core/_force_cancel.py

@@ -0,0 +1,73 @@
+"""Shared helper for writing the canonical 'force-cancelled' terminal state.
+
+Imported by both Executor.force_cancel and Optio.shutdown. Kept in its own
+module to avoid a circular import between executor.py and lifecycle.py.
+
+Spec: docs/2026-04-29-deadline-driven-cancel-design.md
+"""
+import logging as _logging
+import os as _os
+import time as _time
+from datetime import datetime, timezone
+
+from bson import ObjectId
+from motor.motor_asyncio import AsyncIOMotorDatabase
+
+from optio_core.models import ProcessStatus
+from optio_core.state_machine import ACTIVE_STATES
+from optio_core.store import append_log, compute_expire_at
+
+
+_trace_logger = _logging.getLogger("optio_core.cancel_trace")
+_CANCEL_TRACE = _os.environ.get("OPTIO_CANCEL_TRACE", "0").lower() in ("1", "true", "yes")
+
+
+def _trace(fmt: str, *args: object) -> None:
+    if _CANCEL_TRACE:
+        _trace_logger.warning("[%.3f] _force_cancel " + fmt, _time.monotonic(), *args)
+
+
+FORCE_CANCEL_ERROR = "Task did not unwind within cancellation grace period"
+
+
+async def _write_force_cancelled_state(
+    db: AsyncIOMotorDatabase, prefix: str, oid: ObjectId,
+) -> bool:
+    """Conditionally flip an active process to terminal 'failed' state.
+
+    Only updates rows whose current state is in ACTIVE_STATES. A task that
+    won the race to a terminal state owns its own transition and is left
+    alone. Returns True if the row was updated, False otherwise.
+
+    If the row carries a `ttlSeconds` field, also $set `expireAt = now + ttl`
+    so the TTL index evicts it at the same point a cooperative-cancel
+    record would have been evicted (B2 invariant: every terminal-state
+    writer honours TTL).
+    """
+    coll = db[f"{prefix}_processes"]
+    now = datetime.now(timezone.utc)
+    status_doc = ProcessStatus(
+        state="failed", error=FORCE_CANCEL_ERROR, failed_at=now,
+    ).to_dict()
+
+    # Read ttlSeconds so we can compute expireAt for the TTL index.
+    ttl_doc = await coll.find_one({"_id": oid}, {"ttlSeconds": 1})
+    expire_at = compute_expire_at((ttl_doc or {}).get("ttlSeconds"), now=now)
+    set_doc: dict = {"status": status_doc, "widgetUpstream": None}
+    if expire_at is not None:
+        set_doc["expireAt"] = expire_at
+
+    result = await coll.update_one(
+        {"_id": oid, "status.state": {"$in": list(ACTIVE_STATES)}},
+        {"$set": set_doc},
+    )
+    if result.modified_count:
+        _trace("oid=%s WROTE state=failed reason=grace-exceeded", oid)
+        await append_log(
+            db, prefix, oid,
+            "event",
+            "State forced: running -> failed (cancellation grace period exceeded)",
+        )
+        return True
+    _trace("oid=%s no-op: row already in terminal state (lost race)", oid)
+    return False

optio_core/_generated/optio_engine.py

@@ -0,0 +1,399 @@
+# AUTO-GENERATED by @clamator/codegen v0.1.9 from optio-engine-to-api.ts.
+# DO NOT EDIT. Re-run codegen to update.
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from clamator_protocol import ClamatorClient, Contract, MethodEntry
+
+from typing import Any, Literal
+
+from pydantic import AwareDatetime, BaseModel, ConfigDict, Field, RootModel
+
+
+class BlockLaunchesParams(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    launch_filter: dict[str, Any] = Field(..., alias="launchFilter")
+    reason: str | None = None
+
+
+class BlockLaunchesResult1(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[True]
+
+
+class BlockLaunchesResult2(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[False]
+    reason: Literal["invalid-filter"]
+
+
+class BlockLaunchesResult(RootModel[BlockLaunchesResult1 | BlockLaunchesResult2]):
+    root: BlockLaunchesResult1 | BlockLaunchesResult2
+
+
+class CancelParams(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    process_id: str = Field(..., alias="processId", min_length=1)
+
+
+class Status(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    state: Literal[
+        "idle",
+        "scheduled",
+        "running",
+        "done",
+        "failed",
+        "cancel_requested",
+        "cancelling",
+        "cancelled",
+    ]
+    error: str | None = None
+    running_since: AwareDatetime | None = Field(None, alias="runningSince")
+    done_at: AwareDatetime | None = Field(None, alias="doneAt")
+    duration: float | None = None
+    failed_at: AwareDatetime | None = Field(None, alias="failedAt")
+    stopped_at: AwareDatetime | None = Field(None, alias="stoppedAt")
+
+
+class Percent(RootModel[float]):
+    root: float = Field(..., ge=0.0, le=100.0)
+
+
+class Progress(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    percent: Percent | None
+    message: str | None = None
+
+
+class LogItem(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    timestamp: AwareDatetime
+    level: Literal["event", "info", "debug", "warning", "error"]
+    message: str
+    data: dict[str, Any] | None = None
+
+
+class Process(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    field_id: str = Field(..., alias="_id", pattern="^[a-f\\d]{24}$")
+    process_id: str = Field(..., alias="processId")
+    name: str
+    params: dict[str, Any] | None = None
+    metadata: dict[str, Any] | None = None
+    parent_id: str | None = Field(None, alias="parentId", pattern="^[a-f\\d]{24}$")
+    root_id: str = Field(..., alias="rootId", pattern="^[a-f\\d]{24}$")
+    depth: int = Field(..., ge=0)
+    order: int = Field(..., ge=0)
+    cancellable: bool
+    special: bool | None = None
+    warning: str | None = None
+    description: str | None = None
+    status: Status
+    progress: Progress
+    log: list[LogItem]
+    ui_widget: str | None = Field(None, alias="uiWidget")
+    widget_data: Any | None = Field(None, alias="widgetData")
+    supports_resume: bool | None = Field(None, alias="supportsResume")
+    has_saved_state: bool | None = Field(None, alias="hasSavedState")
+    created_at: AwareDatetime = Field(..., alias="createdAt")
+
+
+class CancelResult1(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[True]
+    process: Process
+
+
+class CancelResult2(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[False]
+    reason: Literal["not-found", "not-cancellable"]
+
+
+class CancelResult(RootModel[CancelResult1 | CancelResult2]):
+    root: CancelResult1 | CancelResult2
+
+
+class DismissParams(CancelParams):
+    pass
+
+
+class Progress1(Progress):
+    pass
+
+
+class Process1(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    field_id: str = Field(..., alias="_id", pattern="^[a-f\\d]{24}$")
+    process_id: str = Field(..., alias="processId")
+    name: str
+    params: dict[str, Any] | None = None
+    metadata: dict[str, Any] | None = None
+    parent_id: str | None = Field(None, alias="parentId", pattern="^[a-f\\d]{24}$")
+    root_id: str = Field(..., alias="rootId", pattern="^[a-f\\d]{24}$")
+    depth: int = Field(..., ge=0)
+    order: int = Field(..., ge=0)
+    cancellable: bool
+    special: bool | None = None
+    warning: str | None = None
+    description: str | None = None
+    status: Status
+    progress: Progress1
+    log: list[LogItem]
+    ui_widget: str | None = Field(None, alias="uiWidget")
+    widget_data: Any | None = Field(None, alias="widgetData")
+    supports_resume: bool | None = Field(None, alias="supportsResume")
+    has_saved_state: bool | None = Field(None, alias="hasSavedState")
+    created_at: AwareDatetime = Field(..., alias="createdAt")
+
+
+class DismissResult1(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[True]
+    process: Process1
+
+
+class DismissResult2(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[False]
+    reason: Literal["not-found", "not-dismissable"]
+
+
+class DismissResult(RootModel[DismissResult1 | DismissResult2]):
+    root: DismissResult1 | DismissResult2
+
+
+class GroupCancelParams(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    metadata_filter: dict[str, Any] = Field(..., alias="metadataFilter")
+    block_new_launches: bool | None = Field(None, alias="blockNewLaunches")
+    persist: bool | None = None
+    reason: str | None = None
+
+
+class GroupCancelResult1(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[True]
+    cancelled_count: int = Field(..., alias="cancelledCount", ge=0)
+
+
+class GroupCancelResult2(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[False]
+    reason: Literal["invalid-persist-without-block"]
+
+
+class GroupCancelResult(RootModel[GroupCancelResult1 | GroupCancelResult2]):
+    root: GroupCancelResult1 | GroupCancelResult2
+
+
+class GroupCancelAndWaitParams(GroupCancelParams):
+    pass
+
+
+class GroupCancelAndWaitResult1(GroupCancelResult1):
+    pass
+
+
+class GroupCancelAndWaitResult2(GroupCancelResult2):
+    pass
+
+
+class GroupCancelAndWaitResult(
+    RootModel[GroupCancelAndWaitResult1 | GroupCancelAndWaitResult2]
+):
+    root: GroupCancelAndWaitResult1 | GroupCancelAndWaitResult2
+
+
+class LaunchParams(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    process_id: str = Field(..., alias="processId", min_length=1)
+    resume: bool | None = None
+
+
+class Progress2(Progress):
+    pass
+
+
+class Process2(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    field_id: str = Field(..., alias="_id", pattern="^[a-f\\d]{24}$")
+    process_id: str = Field(..., alias="processId")
+    name: str
+    params: dict[str, Any] | None = None
+    metadata: dict[str, Any] | None = None
+    parent_id: str | None = Field(None, alias="parentId", pattern="^[a-f\\d]{24}$")
+    root_id: str = Field(..., alias="rootId", pattern="^[a-f\\d]{24}$")
+    depth: int = Field(..., ge=0)
+    order: int = Field(..., ge=0)
+    cancellable: bool
+    special: bool | None = None
+    warning: str | None = None
+    description: str | None = None
+    status: Status
+    progress: Progress2
+    log: list[LogItem]
+    ui_widget: str | None = Field(None, alias="uiWidget")
+    widget_data: Any | None = Field(None, alias="widgetData")
+    supports_resume: bool | None = Field(None, alias="supportsResume")
+    has_saved_state: bool | None = Field(None, alias="hasSavedState")
+    created_at: AwareDatetime = Field(..., alias="createdAt")
+
+
+class LaunchResult1(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[True]
+    process: Process2
+
+
+class LaunchResult2(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    ok: Literal[False]
+    reason: Literal[
+        "not-found", "not-launchable", "no-resume-support", "launch-blocked"
+    ]
+
+
+class LaunchResult(RootModel[LaunchResult1 | LaunchResult2]):
+    root: LaunchResult1 | LaunchResult2
+
+
+class ResyncParams(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    clean: bool | None = None
+    metadata_filter: dict[str, Any] | None = Field(None, alias="metadataFilter")
+
+
+class UnblockLaunchesParams(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    launch_filter: dict[str, Any] = Field(..., alias="launchFilter")
+
+
+class UnblockLaunchesResult(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    removed: int = Field(..., ge=0)
+
+
+class OptioEngineClient:
+    def __init__(self, client: ClamatorClient) -> None:
+        self._client = client
+
+    async def block_launches(self, params: BlockLaunchesParams, *, timeout_ms: int | None = None) -> BlockLaunchesResult:
+        raw = await self._client.call("optio-engine", "blockLaunches", params.model_dump(mode='json', by_alias=True), timeout_ms=timeout_ms)
+        return BlockLaunchesResult.model_validate(raw)
+
+    async def cancel(self, params: CancelParams, *, timeout_ms: int | None = None) -> CancelResult:
+        raw = await self._client.call("optio-engine", "cancel", params.model_dump(mode='json', by_alias=True), timeout_ms=timeout_ms)
+        return CancelResult.model_validate(raw)
+
+    async def dismiss(self, params: DismissParams, *, timeout_ms: int | None = None) -> DismissResult:
+        raw = await self._client.call("optio-engine", "dismiss", params.model_dump(mode='json', by_alias=True), timeout_ms=timeout_ms)
+        return DismissResult.model_validate(raw)
+
+    async def group_cancel(self, params: GroupCancelParams, *, timeout_ms: int | None = None) -> GroupCancelResult:
+        raw = await self._client.call("optio-engine", "groupCancel", params.model_dump(mode='json', by_alias=True), timeout_ms=timeout_ms)
+        return GroupCancelResult.model_validate(raw)
+
+    async def group_cancel_and_wait(self, params: GroupCancelAndWaitParams, *, timeout_ms: int | None = None) -> GroupCancelAndWaitResult:
+        raw = await self._client.call("optio-engine", "groupCancelAndWait", params.model_dump(mode='json', by_alias=True), timeout_ms=timeout_ms)
+        return GroupCancelAndWaitResult.model_validate(raw)
+
+    async def launch(self, params: LaunchParams, *, timeout_ms: int | None = None) -> LaunchResult:
+        raw = await self._client.call("optio-engine", "launch", params.model_dump(mode='json', by_alias=True), timeout_ms=timeout_ms)
+        return LaunchResult.model_validate(raw)
+
+    async def resync(self, params: ResyncParams) -> None:
+        await self._client.notify("optio-engine", "resync", params.model_dump(mode='json', by_alias=True))
+
+    async def unblock_launches(self, params: UnblockLaunchesParams, *, timeout_ms: int | None = None) -> UnblockLaunchesResult:
+        raw = await self._client.call("optio-engine", "unblockLaunches", params.model_dump(mode='json', by_alias=True), timeout_ms=timeout_ms)
+        return UnblockLaunchesResult.model_validate(raw)
+
+
+class OptioEngineService(ABC):
+    @abstractmethod
+    async def block_launches(self, params: BlockLaunchesParams) -> BlockLaunchesResult: ...
+
+    @abstractmethod
+    async def cancel(self, params: CancelParams) -> CancelResult: ...
+
+    @abstractmethod
+    async def dismiss(self, params: DismissParams) -> DismissResult: ...
+
+    @abstractmethod
+    async def group_cancel(self, params: GroupCancelParams) -> GroupCancelResult: ...
+
+    @abstractmethod
+    async def group_cancel_and_wait(self, params: GroupCancelAndWaitParams) -> GroupCancelAndWaitResult: ...
+
+    @abstractmethod
+    async def launch(self, params: LaunchParams) -> LaunchResult: ...
+
+    @abstractmethod
+    async def resync(self, params: ResyncParams) -> None: ...
+
+    @abstractmethod
+    async def unblock_launches(self, params: UnblockLaunchesParams) -> UnblockLaunchesResult: ...
+
+
+METHODS = {
+    "blockLaunches": MethodEntry(params_model=BlockLaunchesParams, result_model=BlockLaunchesResult, handler_attr="block_launches"),
+    "cancel": MethodEntry(params_model=CancelParams, result_model=CancelResult, handler_attr="cancel"),
+    "dismiss": MethodEntry(params_model=DismissParams, result_model=DismissResult, handler_attr="dismiss"),
+    "groupCancel": MethodEntry(params_model=GroupCancelParams, result_model=GroupCancelResult, handler_attr="group_cancel"),
+    "groupCancelAndWait": MethodEntry(params_model=GroupCancelAndWaitParams, result_model=GroupCancelAndWaitResult, handler_attr="group_cancel_and_wait"),
+    "launch": MethodEntry(params_model=LaunchParams, result_model=LaunchResult, handler_attr="launch"),
+    "resync": MethodEntry(params_model=ResyncParams, result_model=None, handler_attr="resync"),
+    "unblockLaunches": MethodEntry(params_model=UnblockLaunchesParams, result_model=UnblockLaunchesResult, handler_attr="unblock_launches"),
+}
+
+optio_engine_contract = Contract(
+    service="optio-engine",
+    methods=METHODS,
+)