dex-python-sdk 0.0.2__cp311-abi3-win_amd64.whl

dex/__init__.py

@@ -0,0 +1,146 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+from dex.attribute import (
+    Attribute,
+    AttributeIndex,
+    AttributeLock,
+    AttributeMap,
+    IndexType,
+)
+from dex.blob_cache import BlobCache, BlobCacheConfig, open_blob_cache
+from dex.channel import Channel, ChannelMap
+from dex.client import Client
+from dex.client_options import ClientOptions
+from dex.codec import (
+    BOOL,
+    BYTES,
+    DOUBLE,
+    INT64,
+    STRING,
+    Codec,
+    CodecRegistry,
+    JsonCodec,
+    Value,
+    WireKind,
+)
+from dex.condition import ConditionCombination
+from dex.context import Context
+from dex.flow import Flow, PersistenceSchema, Registry, RPCResult, rpc
+from dex.flow_config import ActiveStepSearchMode, FlowConfig
+from dex.flow_info import FlowInfo, FlowStatus, HealthInfo, SearchFlowEntry
+from dex.flow_options import (
+    IdReusePolicy,
+    ResetFlowOptions,
+    ResetType,
+    StartFlowOptions,
+    StopFlowOptions,
+    StopType,
+)
+from dex.runtime_errors import (
+    DexException,
+    ErrorSubStatus,
+    FlowErrorType,
+    FlowUncompletedError,
+    LongPollTimeoutError,
+)
+from dex.step import (
+    RetryPolicy,
+    Step,
+    StepDecision,
+    StepDurability,
+    StepList,
+    StepMovement,
+    StepOptions,
+    WaitForFailurePolicy,
+    dead_end,
+    force_complete,
+    force_complete_when_channels_empty,
+    force_fail,
+    go_to,
+    go_to_multi,
+    graceful_complete,
+)
+from dex.step_execution import StepExecutionId, TimerId
+from dex.timer import Timer
+from dex.wait import Wait
+from dex.worker import Worker
+from dex.worker_options import WorkerOptions, WorkerTarget
+
+__all__ = [
+    "BOOL",
+    "BYTES",
+    "DOUBLE",
+    "INT64",
+    "STRING",
+    "ActiveStepSearchMode",
+    "Attribute",
+    "AttributeIndex",
+    "AttributeLock",
+    "AttributeMap",
+    "BlobCache",
+    "BlobCacheConfig",
+    "Channel",
+    "ChannelMap",
+    "Client",
+    "ClientOptions",
+    "Codec",
+    "CodecRegistry",
+    "ConditionCombination",
+    "Context",
+    "DexException",
+    "ErrorSubStatus",
+    "Flow",
+    "FlowConfig",
+    "FlowErrorType",
+    "FlowInfo",
+    "FlowStatus",
+    "FlowUncompletedError",
+    "HealthInfo",
+    "IdReusePolicy",
+    "IndexType",
+    "JsonCodec",
+    "LongPollTimeoutError",
+    "PersistenceSchema",
+    "RPCResult",
+    "Registry",
+    "ResetFlowOptions",
+    "ResetType",
+    "RetryPolicy",
+    "SearchFlowEntry",
+    "StartFlowOptions",
+    "StepExecutionId",
+    "StepDecision",
+    "Step",
+    "StepList",
+    "StepDurability",
+    "StepMovement",
+    "StepOptions",
+    "StopFlowOptions",
+    "StopType",
+    "Timer",
+    "TimerId",
+    "Value",
+    "Wait",
+    "WaitForFailurePolicy",
+    "WireKind",
+    "Worker",
+    "WorkerOptions",
+    "WorkerTarget",
+    "dead_end",
+    "force_complete",
+    "force_complete_when_channels_empty",
+    "force_fail",
+    "graceful_complete",
+    "go_to",
+    "go_to_multi",
+    "open_blob_cache",
+    "rpc",
+]

dex/_grpc_errors.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2026 Super Durable, Inc.
+#
+# Licensed under the Super Durable Source License 1.0.
+# You may not use this file except in compliance with the License.
+# See the LICENSE file in the repository root.
+#
+# SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+
+from __future__ import annotations
+
+from typing import cast
+
+import grpc
+from google.protobuf import any_pb2
+from google.rpc import status_pb2
+from grpc_status import rpc_status
+
+from dex.dexpb import dex_pb2 as pb
+from dex.runtime_errors import DexException, ErrorSubStatus
+
+
+def translate_rpc_error(error: grpc.RpcError) -> DexException:
+    details: pb.ErrorResponse | None = None
+    status = rpc_status.from_call(cast(grpc.Call, error))
+    if status is not None:
+        for packed in status.details:
+            candidate = pb.ErrorResponse()
+            if packed.Is(candidate.DESCRIPTOR):
+                packed.Unpack(candidate)
+                details = candidate
+                break
+    detail = (
+        details.detail if details is not None and details.detail else error.details()
+    )
+    return DexException(
+        error.code(),
+        _map_sub_status(details.sub_status) if details is not None else None,
+        detail,
+        details.original_worker_error_type if details is not None else "",
+        details.original_worker_error_detail if details is not None else "",
+    )
+
+
+def abort_worker_error(
+    context: grpc.ServicerContext,
+    error: BaseException,
+) -> None:
+    message = str(error) or type(error).__name__
+    worker_error = pb.WorkerErrorResponse(
+        detail=message,
+        error_type=f"{type(error).__module__}.{type(error).__qualname__}",
+    )
+    packed = any_pb2.Any()
+    packed.Pack(worker_error)
+    status = status_pb2.Status(
+        code=grpc.StatusCode.UNKNOWN.value[0],
+        message=message,
+        details=[packed],
+    )
+    context.abort_with_status(rpc_status.to_status(status))
+
+
+def _map_sub_status(value: int) -> ErrorSubStatus | None:
+    statuses: dict[int, ErrorSubStatus] = {
+        int(pb.ERROR_SUB_STATUS_UNCATEGORIZED): ErrorSubStatus.UNCATEGORIZED,
+        int(
+            pb.ERROR_SUB_STATUS_FLOW_ALREADY_STARTED
+        ): ErrorSubStatus.FLOW_ALREADY_STARTED,
+        int(pb.ERROR_SUB_STATUS_FLOW_NOT_EXISTS): ErrorSubStatus.FLOW_NOT_EXISTS,
+        int(pb.ERROR_SUB_STATUS_WORKER_API_ERROR): ErrorSubStatus.WORKER_API_ERROR,
+        int(pb.ERROR_SUB_STATUS_LONG_POLL_TIME_OUT): ErrorSubStatus.LONG_POLL_TIMEOUT,
+    }
+    return statuses.get(value)

dex/_invocation_context.py

@@ -0,0 +1,269 @@
+# Copyright (c) 2026 Super Durable, Inc.
+#
+# Licensed under the Super Durable Source License 1.0.
+# You may not use this file except in compliance with the License.
+# See the LICENSE file in the repository root.
+#
+# SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Sequence, TypeVar, cast
+
+from dex._utils import require_name
+from dex._value_mapper import ValueMapper
+from dex.attribute import Attribute, AttributeMap
+from dex.channel import Channel, ChannelMap
+from dex.codec import Codec
+from dex.dexpb import dex_pb2 as pb
+from dex.flow import Registry, _RegisteredFlow
+
+ValueT = TypeVar("ValueT")
+_Definition = Attribute[Any] | AttributeMap[Any] | Channel[Any] | ChannelMap[Any]
+
+
+class InvocationMethod(Enum):
+    WAIT_FOR = "wait_for"
+    EXECUTE = "execute"
+    RPC = "rpc"
+
+
+class InvocationContext:
+    def __init__(
+        self,
+        method: InvocationMethod,
+        flow: _RegisteredFlow,
+        metadata: pb.Context,
+        values: ValueMapper,
+        attributes: Sequence[pb.KV],
+        locals: Sequence[pb.KV] = (),
+        condition_results: pb.ConditionResults | None = None,
+        channel_infos: dict[str, pb.ChannelInfo] | None = None,
+    ) -> None:
+        self._method = method
+        self._flow = flow
+        self._metadata = metadata
+        self._values = values
+        self._attributes = self._map_values("Attribute", attributes)
+        self._locals = self._map_values("step-execution local", locals)
+        self._condition_results = condition_results
+        self._channel_infos = dict(channel_infos or {})
+        self.attribute_writes: dict[str, pb.AttributeWrite] = {}
+        self.local_writes: dict[str, pb.KV] = {}
+        self.events: list[pb.KV] = []
+        self.publications: list[pb.ChannelMessage] = []
+        self._event_names: set[str] = set()
+
+    @property
+    def flow_id(self) -> str:
+        return self._metadata.flow_id
+
+    @property
+    def run_id(self) -> str:
+        return self._metadata.run_id
+
+    @property
+    def step_execution_id(self) -> str:
+        return self._metadata.step_execution_id
+
+    @property
+    def from_step_execution_id(self) -> str:
+        return self._metadata.from_step_execution_id
+
+    @property
+    def attempt(self) -> int:
+        return self._metadata.attempt
+
+    def has_timer_fired(self, index: int | None = None) -> bool:
+        if self._condition_results is None:
+            return False
+        results = self._condition_results.timer_results
+        if index is None:
+            return any(
+                result.condition_status == pb.CONDITION_STATUS_COMPLETED
+                for result in results
+            )
+        return (
+            0 <= index < len(results)
+            and results[index].condition_status == pb.CONDITION_STATUS_COMPLETED
+        )
+
+    def wait_for_method_failed(self) -> bool:
+        return bool(
+            self._condition_results is not None
+            and self._condition_results.wait_for_failed
+        )
+
+    def set_step_execution_local(self, key: str, value: object) -> None:
+        require_name(key)
+        self.local_writes[key] = pb.KV(
+            key=key,
+            value=self._values.encode_dynamic(value),
+        )
+
+    def get_step_execution_local(
+        self,
+        key: str,
+        value_type: type[ValueT],
+    ) -> ValueT | None:
+        require_name(key)
+        entry = self.local_writes.get(key)
+        value = entry.value if entry is not None else self._locals.get(key)
+        if value is None:
+            return None
+        return cast(
+            ValueT,
+            self._values.decode(value, self._flow_codec(value_type)),
+        )
+
+    def record_event(self, name: str, value: object) -> None:
+        require_name(name)
+        if name in self._event_names:
+            raise ValueError(f"event was already recorded: {name}")
+        self._event_names.add(name)
+        self.events.append(pb.KV(key=name, value=self._values.encode_dynamic(value)))
+
+    def _get_attribute(
+        self,
+        definition: Attribute[ValueT] | AttributeMap[ValueT],
+        instance: str | None,
+    ) -> ValueT:
+        self._require_registered(definition)
+        key = self._physical_name(definition, instance)
+        write = self.attribute_writes.get(key)
+        if write is not None:
+            if write.value.WhichOneof("kind") == "null_value":
+                return cast(ValueT, self._default_value(definition.value_type))
+            value: pb.Value | None = write.value
+        else:
+            value = self._attributes.get(key)
+        if value is None:
+            return cast(ValueT, self._default_value(definition.value_type))
+        codec = self._flow_codec(definition.value_type)
+        return cast(ValueT, self._values.decode(value, codec))
+
+    def _set_attribute(
+        self,
+        definition: Attribute[ValueT] | AttributeMap[ValueT],
+        instance: str | None,
+        value: ValueT,
+    ) -> None:
+        self._require_registered(definition)
+        key = self._physical_name(definition, instance)
+        write = pb.AttributeWrite(
+            key=key,
+            value=self._values.encode(value, self._flow_codec(definition.value_type)),
+        )
+        index = self._values.index_config(
+            definition.index,
+            isinstance(definition, AttributeMap),
+        )
+        if index is not None:
+            write.index_config.CopyFrom(index)
+        self.attribute_writes[key] = write
+
+    def _delete_attribute(
+        self,
+        definition: Attribute[object] | AttributeMap[object],
+        instance: str | None,
+    ) -> None:
+        self._require_registered(definition)
+        key = self._physical_name(definition, instance)
+        write = pb.AttributeWrite(key=key, value=self._values.deletion())
+        index = self._values.index_config(
+            definition.index,
+            isinstance(definition, AttributeMap),
+        )
+        if index is not None:
+            write.index_config.CopyFrom(index)
+        self.attribute_writes[key] = write
+
+    def _publish_channel(
+        self,
+        definition: Channel[ValueT] | ChannelMap[ValueT],
+        instance: str | None,
+        value: ValueT,
+    ) -> None:
+        self._require_registered(definition)
+        name = self._physical_name(definition, instance)
+        self.publications.append(
+            pb.ChannelMessage(
+                channel_name=name,
+                value=self._values.encode(
+                    value,
+                    self._flow_codec(definition.value_type),
+                ),
+            )
+        )
+        if self._method is InvocationMethod.RPC:
+            current = self._channel_infos.get(name)
+            self._channel_infos[name] = pb.ChannelInfo(
+                size=(current.size if current is not None else 0) + 1
+            )
+
+    def _channel_size(
+        self,
+        definition: Channel[object] | ChannelMap[object],
+        instance: str | None,
+    ) -> int:
+        self._require_registered(definition)
+        info = self._channel_infos.get(self._physical_name(definition, instance))
+        return info.size if info is not None else 0
+
+    def _channel_results(
+        self,
+        definition: Channel[ValueT] | ChannelMap[ValueT],
+        instance: str | None,
+    ) -> Sequence[ValueT]:
+        self._require_registered(definition)
+        if self._condition_results is None:
+            return ()
+        name = self._physical_name(definition, instance)
+        codec = self._flow_codec(definition.value_type)
+        return tuple(
+            cast(ValueT, self._values.decode(value, codec))
+            for result in self._condition_results.channel_results
+            if result.channel_name == name
+            and result.condition_status == pb.CONDITION_STATUS_COMPLETED
+            for value in result.values
+        )
+
+    def _flow_codec(self, value_type: object) -> Codec[Any]:
+        return self._values.codec(value_type)
+
+    def _require_registered(self, definition: _Definition) -> None:
+        registered = self._flow.persistence.get(definition.name)
+        if registered is not definition:
+            raise ValueError(
+                f"persistence definition does not belong to Flow: {definition.name}"
+            )
+
+    @staticmethod
+    def _physical_name(definition: _Definition, instance: str | None) -> str:
+        if isinstance(definition, (AttributeMap, ChannelMap)):
+            if instance is None:
+                raise ValueError("dynamic definition requires an instance")
+            return Registry.physical_name(definition.name, instance)
+        if instance is not None:
+            raise ValueError("static definition cannot use an instance")
+        return definition.name
+
+    @staticmethod
+    def _map_values(kind: str, entries: Sequence[pb.KV]) -> dict[str, pb.Value]:
+        values: dict[str, pb.Value] = {}
+        for entry in entries:
+            if not entry.key or not entry.HasField("value") or entry.key in values:
+                raise ValueError(f"invalid or duplicate {kind}")
+            values[entry.key] = entry.value
+        return values
+
+    @staticmethod
+    def _default_value(value_type: object) -> object | None:
+        if value_type is bool:
+            return False
+        if value_type is int:
+            return 0
+        if value_type is float:
+            return 0.0
+        return None

dex/_native.pyi

@@ -0,0 +1,20 @@
+# Copyright (c) 2026 Super Durable, Inc.
+#
+# Licensed under the Super Durable Source License 1.0.
+# You may not use this file except in compliance with the License.
+# See the LICENSE file in the repository root.
+#
+# SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+
+class NativeBlobCache:
+    def __init__(
+        self,
+        directory: str,
+        max_bytes: int,
+        frequency_counters: int,
+    ) -> None: ...
+    def get(self, blob_id: str) -> bytes | None: ...
+    def put(self, blob_id: str, payload: bytes) -> bool: ...
+    def delete(self, blob_id: str) -> None: ...
+    def delete_all(self) -> None: ...
+    def close(self) -> None: ...

dex/_utils.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2026 Super Durable, Inc.
+#
+# Licensed under the Super Durable Source License 1.0.
+# You may not use this file except in compliance with the License.
+# See the LICENSE file in the repository root.
+#
+# SPDX-License-Identifier: LicenseRef-Super-Durable-1.0
+
+
+def require_name(name: str) -> str:
+    if not name.strip():
+        raise ValueError("durable name is required")
+    return name
+
+
+def validate_condition_id(condition_id: str | None) -> None:
+    if condition_id is not None and not condition_id:
+        raise ValueError("condition ID must not be empty")