dex-python-sdk 0.0.1__py3-none-any.whl

dex/command_request.py

@@ -0,0 +1,130 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from dex.errors import WorkflowDefinitionError
+from dex.dex_api.models import CommandWaitingType
+from dex.dex_api.models.command_combination import CommandCombination
+from dex.dex_api.models.command_request import (
+    CommandRequest as IdlCommandRequest,
+)
+from dex.dex_api.models.inter_state_channel_command import (
+    InterStateChannelCommand as IdlInternalChannelCommand,
+)
+from dex.dex_api.models.signal_command import SignalCommand as IdlSignalCommand
+from dex.dex_api.models.timer_command import TimerCommand as IdlTimerCommand
+
+
+@dataclass
+class TimerCommand:
+    command_id: str
+    duration_seconds: int
+
+    @classmethod
+    def by_seconds(cls, duration_seconds: int, command_id: Optional[str] = None):
+        return TimerCommand(
+            command_id if command_id is not None else "", duration_seconds
+        )
+
+
+@dataclass
+class InternalChannelCommand:
+    command_id: str
+    channel_name: str
+
+    @classmethod
+    def by_name(cls, channel_name: str, command_id: Optional[str] = None):
+        return InternalChannelCommand(
+            command_id if command_id is not None else "", channel_name
+        )
+
+
+@dataclass
+class SignalChannelCommand:
+    command_id: str
+    channel_name: str
+
+    @classmethod
+    def by_name(cls, channel_name: str, command_id: Optional[str] = None):
+        return SignalChannelCommand(
+            command_id if command_id is not None else "",
+            channel_name,
+        )
+
+
+BaseCommand = Union[TimerCommand, InternalChannelCommand, SignalChannelCommand]
+
+
+@dataclass
+class CommandRequest:
+    commands: list[BaseCommand]
+    command_waiting_type: CommandWaitingType
+    command_combinations: list[CommandCombination]
+
+    @classmethod
+    def for_any_command_completed(cls, *commands: BaseCommand):
+        bc = [c for c in commands]
+        return CommandRequest(bc, CommandWaitingType.ANY_COMPLETED, [])
+
+    @classmethod
+    def for_all_command_completed(cls, *commands: BaseCommand):
+        bc = [c for c in commands]
+        return CommandRequest(bc, CommandWaitingType.ALL_COMPLETED, [])
+
+    @classmethod
+    def for_any_command_combination_completed(
+        cls, command_combinations_list: list[list[str]], *commands: BaseCommand
+    ):
+        return CommandRequest(
+            list(commands),
+            CommandWaitingType.ANY_COMBINATION_COMPLETED,
+            [CommandCombination(c) for c in command_combinations_list],
+        )
+
+    @classmethod
+    def empty(cls):
+        return CommandRequest(list(), CommandWaitingType.ALL_COMPLETED, [])
+
+
+def _to_idl_command_request(request: CommandRequest) -> IdlCommandRequest:
+    req = IdlCommandRequest(
+        command_waiting_type=request.command_waiting_type,
+    )
+
+    timer_commands = []
+    internal_channel_commands = []
+    signal_commands = []
+    for t in request.commands:
+        if isinstance(t, TimerCommand):
+            timer_commands.append(IdlTimerCommand(t.duration_seconds, t.command_id))
+        elif isinstance(t, InternalChannelCommand):
+            internal_channel_commands.append(
+                IdlInternalChannelCommand(t.channel_name, t.command_id)
+            )
+        elif isinstance(t, SignalChannelCommand):
+            signal_commands.append(IdlSignalCommand(t.channel_name, t.command_id))
+        else:
+            raise WorkflowDefinitionError(f"unknown command {t.__class__.__qualname__}")
+
+    if len(timer_commands) > 0:
+        req.timer_commands = timer_commands
+    if len(internal_channel_commands) > 0:
+        req.inter_state_channel_commands = internal_channel_commands
+    if len(signal_commands) > 0:
+        req.signal_commands = signal_commands
+    if len(request.command_combinations) > 0:
+        req.command_combinations = request.command_combinations
+    return req

dex/command_results.py

@@ -0,0 +1,116 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+from dataclasses import dataclass
+from typing import Any, Union, Optional
+
+from dex.errors import WorkflowDefinitionError, NotRegisteredError
+from dex.dex_api.models import (
+    ChannelRequestStatus,
+    CommandResults as IdlCommandResults,
+    TimerStatus,
+)
+from dex.dex_api.types import Unset
+from dex.object_encoder import ObjectEncoder
+from dex.type_store import TypeStore
+
+
+@dataclass
+class TimerCommandResult:
+    status: TimerStatus
+    command_id: str
+
+
+@dataclass
+class InternalChannelCommandResult:
+    channel_name: str
+    value: Any
+    status: ChannelRequestStatus
+    command_id: str
+
+
+@dataclass
+class SignalChannelCommandResult:
+    channel_name: str
+    value: Any
+    status: ChannelRequestStatus
+    command_id: str
+
+
+@dataclass
+class CommandResults:
+    timer_commands: list[TimerCommandResult]
+    internal_channel_commands: list[InternalChannelCommandResult]
+    signal_channel_commands: list[SignalChannelCommandResult]
+    wait_until_api_succeeded: Optional[bool] = None
+
+
+def from_idl_command_results(
+    idl_results: Union[Unset, IdlCommandResults],
+    internal_channel_types: TypeStore,
+    signal_channel_types: dict[str, typing.Optional[type]],
+    object_encoder: ObjectEncoder,
+) -> CommandResults:
+    results = CommandResults(list(), list(), list(), None)
+    if isinstance(idl_results, Unset):
+        return results
+
+    if not isinstance(idl_results.timer_results, Unset):
+        for timer in idl_results.timer_results:
+            results.timer_commands.append(
+                TimerCommandResult(timer.timer_status, timer.command_id)
+            )
+
+    if not isinstance(idl_results.inter_state_channel_results, Unset):
+        for inter in idl_results.inter_state_channel_results:
+
+            try:
+                val_type = internal_channel_types.get_type(inter.channel_name)
+            except NotRegisteredError as exception:
+                raise WorkflowDefinitionError(
+                    "internal channel is not registered: " + inter.channel_name
+                ) from exception
+
+            encoded = object_encoder.decode(inter.value, val_type)
+
+            results.internal_channel_commands.append(
+                InternalChannelCommandResult(
+                    inter.channel_name,
+                    encoded,
+                    inter.request_status,
+                    inter.command_id,
+                )
+            )
+
+    if not isinstance(idl_results.signal_results, Unset):
+        for sig in idl_results.signal_results:
+            results.signal_channel_commands.append(
+                SignalChannelCommandResult(
+                    sig.signal_channel_name,
+                    object_encoder.decode(
+                        sig.signal_value,
+                        signal_channel_types.get(sig.signal_channel_name),
+                    ),
+                    sig.signal_request_status,
+                    sig.command_id,
+                )
+            )
+
+    if not isinstance(idl_results.state_wait_until_failed, Unset):
+        # The server will set state_wait_until_failed to true if the waitUntil API failed.
+        # Hence, flag inversion is needed here to indicate that the waitUntil API succeeded.
+        results.wait_until_api_succeeded = not idl_results.state_wait_until_failed
+
+    return results

dex/communication.py

@@ -0,0 +1,141 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Optional, Union
+
+from dex.errors import WorkflowDefinitionError, NotRegisteredError
+from dex.dex_api.models import (
+    EncodedObject,
+    InterStateChannelPublishing,
+    WorkflowWorkerRpcRequestInternalChannelInfos,
+    WorkflowWorkerRpcRequestSignalChannelInfos,
+)
+from dex.dex_api.types import Unset
+from dex.object_encoder import ObjectEncoder
+from dex.state_movement import StateMovement
+from dex.type_store import TypeStore
+
+
+class Communication:
+    _internal_channel_type_store: TypeStore
+    _signal_channel_type_store: dict[str, Optional[type]]
+    _object_encoder: ObjectEncoder
+    _to_publish_internal_channel: dict[str, list[Union[EncodedObject, Unset]]]
+    _state_movements: list[StateMovement]
+    _internal_channel_infos: Optional[WorkflowWorkerRpcRequestInternalChannelInfos]
+    _signal_channel_infos: Optional[WorkflowWorkerRpcRequestSignalChannelInfos]
+
+    def __init__(
+        self,
+        internal_channel_type_store: TypeStore,
+        signal_channel_type_store: dict[str, Optional[type]],
+        object_encoder: ObjectEncoder,
+        internal_channel_infos: Optional[WorkflowWorkerRpcRequestInternalChannelInfos],
+        signal_channel_infos: Optional[WorkflowWorkerRpcRequestSignalChannelInfos],
+    ):
+        self._object_encoder = object_encoder
+        self._internal_channel_type_store = internal_channel_type_store
+        self._signal_channel_type_store = signal_channel_type_store
+        self._to_publish_internal_channel = {}
+        self._state_movements = []
+        self._internal_channel_infos = internal_channel_infos
+        self._signal_channel_infos = signal_channel_infos
+
+    def trigger_state_execution(self, state: Union[str, type], state_input: Any = None):
+        """
+
+        Args:
+            state: the workflowState TODO the type hint should be type[WorkflowState]
+            state_input: the input of the state
+        """
+        movement = StateMovement.create(state, state_input)
+        self._state_movements.append(movement)
+
+    def publish_to_internal_channel(self, channel_name: str, value: Any = None):
+        try:
+            registered_type = self._internal_channel_type_store.get_type(channel_name)
+        except NotRegisteredError as exception:
+            raise WorkflowDefinitionError(
+                f"InternalChannel channel_name is not defined {channel_name}"
+            ) from exception
+
+        if (
+            value is not None
+            and registered_type is not None
+            and not isinstance(value, registered_type)
+        ):
+            raise WorkflowDefinitionError(
+                f"InternalChannel value is not of type {registered_type}"
+            )
+        vals = self._to_publish_internal_channel.get(channel_name)
+        if vals is None:
+            vals = []
+        vals.append(self._object_encoder.encode(value))
+        self._to_publish_internal_channel[channel_name] = vals
+
+    def get_to_publishing_internal_channel(self) -> list[InterStateChannelPublishing]:
+        pubs = []
+        for name, vals in self._to_publish_internal_channel.items():
+            for val in vals:
+                pubs.append(InterStateChannelPublishing(name, val))
+        return pubs
+
+    def get_to_trigger_state_movements(self) -> list[StateMovement]:
+        return self._state_movements
+
+    def get_internal_channel_size(self, channel_name):
+        is_type_registered = self._internal_channel_type_store.is_valid_name_or_prefix(
+            channel_name
+        )
+
+        if is_type_registered is False:
+            raise WorkflowDefinitionError(
+                f"InternalChannel channel_name is not defined {channel_name}"
+            )
+
+        if (
+            self._internal_channel_infos is not None
+            and channel_name in self._internal_channel_infos
+        ):
+            server_channel_size = self._internal_channel_infos[channel_name].size
+        else:
+            server_channel_size = 0
+
+        if channel_name in self._to_publish_internal_channel:
+            buffer_channel_size = len(self._to_publish_internal_channel[channel_name])
+        else:
+            buffer_channel_size = 0
+
+        return server_channel_size + buffer_channel_size
+
+    def get_signal_channel_size(self, channel_name):
+        registered_type = self._signal_channel_type_store.get(channel_name)
+
+        if registered_type is None:
+            for name, t in self._signal_channel_type_store.items():
+                if channel_name.startswith(name):
+                    registered_type = t
+
+        if registered_type is None:
+            raise WorkflowDefinitionError(
+                f"SignalChannel channel_name is not defined {channel_name}"
+            )
+
+        if (
+            self._signal_channel_infos is not None
+            and channel_name in self._signal_channel_infos
+        ):
+            return self._signal_channel_infos[channel_name].size
+        else:
+            return 0

dex/communication_schema.py

@@ -0,0 +1,68 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional, Union
+
+
+class CommunicationMethodType(Enum):
+    SignalChannel = 1
+    InternalChannel = 2
+
+
+@dataclass
+class CommunicationMethod:
+    name: str
+    method_type: CommunicationMethodType
+    value_type: Optional[type]
+    is_prefix: bool
+
+    @classmethod
+    def signal_channel_def(cls, name: str, value_type: Union[type, None]):
+        return CommunicationMethod(
+            name,
+            CommunicationMethodType.SignalChannel,
+            value_type if value_type is not None else type(None),
+            False,
+        )
+
+    @classmethod
+    def internal_channel_def(cls, name: str, value_type: Union[type, None]):
+        return CommunicationMethod(
+            name,
+            CommunicationMethodType.InternalChannel,
+            value_type if value_type is not None else type(None),
+            False,
+        )
+
+    @classmethod
+    def internal_channel_def_by_prefix(
+        cls, name_prefix: str, value_type: Union[type, None]
+    ):
+        return CommunicationMethod(
+            name_prefix,
+            CommunicationMethodType.InternalChannel,
+            value_type if value_type is not None else type(None),
+            True,
+        )
+
+
+@dataclass
+class CommunicationSchema:
+    communication_methods: List[CommunicationMethod] = field(default_factory=list)
+
+    @classmethod
+    def create(cls, *methods: CommunicationMethod):
+        return CommunicationSchema(list(methods))

dex/data_attributes.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Union
+
+from dex.errors import WorkflowDefinitionError
+from dex.dex_api.models import EncodedObject
+from dex.dex_api.types import Unset
+from dex.object_encoder import ObjectEncoder
+from dex.type_store import TypeStore
+
+
+class DataAttributes:
+    _type_store: TypeStore
+    _object_encoder: ObjectEncoder
+    _current_values: dict[str, Union[EncodedObject, None, Unset]]
+    _updated_values_to_return: dict[str, Union[EncodedObject, Unset]]
+
+    def __init__(
+        self,
+        type_store: TypeStore,
+        object_encoder: ObjectEncoder,
+        current_values: dict[str, Union[EncodedObject, None, Unset]],
+    ):
+        self._object_encoder = object_encoder
+        self._type_store = type_store
+        self._current_values = current_values
+        self._updated_values_to_return = {}
+
+    def get_data_attribute(self, key: str) -> Any:
+        is_registered = self._type_store.is_valid_name_or_prefix(key)
+        if not is_registered:
+            raise WorkflowDefinitionError(f"data attribute %s is not registered {key}")
+
+        encoded_object = self._current_values.get(key)
+        if encoded_object is None:
+            return None
+
+        registered_type = self._type_store.get_type(key)
+        return self._object_encoder.decode(encoded_object, registered_type)
+
+    def set_data_attribute(self, key: str, value: Any):
+        is_registered = self._type_store.is_valid_name_or_prefix(key)
+        if not is_registered:
+            raise WorkflowDefinitionError(
+                f"data attribute {key} is not registered {key}"
+            )
+
+        registered_type = self._type_store.get_type(key)
+        if (
+            value is not None
+            and registered_type is not None
+            and not isinstance(value, registered_type)
+        ):
+            raise WorkflowDefinitionError(
+                f"data attribute {key} is of the right type {registered_type}"
+            )
+
+        encoded_value = self._object_encoder.encode(value)
+        self._current_values[key] = encoded_value
+        self._updated_values_to_return[key] = encoded_value
+
+    def get_updated_values_to_return(self) -> dict[str, Union[EncodedObject, Unset]]:
+        return self._updated_values_to_return

dex/dexpb/__init__.py

@@ -0,0 +1 @@
+# Generated package for Dex protobuf stubs.