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

dex/tests/test_workflow_state_options.py

@@ -0,0 +1,118 @@
+# 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.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.dex_api.models import IDReusePolicy
+from dex.dex_api.models import (
+    PersistenceLoadingPolicy,
+    PersistenceLoadingType,
+    WorkflowStateOptions as IdlWorkflowStateOptions,
+    RetryPolicy,
+    WaitUntilApiFailurePolicy,
+)
+from dex.tests.worker_server import registry
+from dex.tests.workflows.state_options_workflow import (
+    StateOptionsWorkflow1,
+    StateOptionsWorkflow2,
+)
+from dex.workflow_options import WorkflowOptions
+from dex.workflow_state_options import WorkflowStateOptions, _to_idl_state_options
+from ..errors import WorkflowFailed
+
+class TestWorkflowStateOptions(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_convert_to_idl(self):
+        empty_idl = IdlWorkflowStateOptions()
+        assert empty_idl == _to_idl_state_options(False, None, {})
+
+        non_empty = WorkflowStateOptions(
+            "state-id",
+            search_attributes_loading_policy=PersistenceLoadingPolicy(
+                persistence_loading_type=PersistenceLoadingType.LOAD_ALL_WITHOUT_LOCKING
+            ),
+        )
+        non_empty_idl = IdlWorkflowStateOptions(
+            skip_wait_until=True,
+            search_attributes_loading_policy=PersistenceLoadingPolicy(
+                persistence_loading_type=PersistenceLoadingType.LOAD_ALL_WITHOUT_LOCKING
+            ),
+        )
+        assert non_empty_idl == _to_idl_state_options(True, non_empty, {})
+        non_empty.state_id = "state-id-2"
+        assert non_empty.state_id == "state-id-2"
+
+    """Test that proceed_to_execute_when_wait_until_retry_exhausted correctly handles both enum values."""
+
+    def test_proceed_to_execute_when_wait_until_retry_exhausted(self):
+        retry_policy = RetryPolicy(maximum_attempts=1)
+
+        # Test PROCEED_ON_FAILURE
+        options_proceed = WorkflowStateOptions(
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.PROCEED_ON_FAILURE,
+            wait_until_api_retry_policy=retry_policy,
+        )
+        result_proceed = _to_idl_state_options(False, options_proceed, {})
+        assert (
+            result_proceed.wait_until_api_failure_policy
+            == WaitUntilApiFailurePolicy.PROCEED_ON_FAILURE
+        )
+
+        # Test FAIL_WORKFLOW_ON_FAILURE
+        options_fail = WorkflowStateOptions(
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.FAIL_WORKFLOW_ON_FAILURE,
+            wait_until_api_retry_policy=retry_policy,
+        )
+        result_fail = _to_idl_state_options(False, options_fail, {})
+        assert (
+            result_fail.wait_until_api_failure_policy
+            == WaitUntilApiFailurePolicy.FAIL_WORKFLOW_ON_FAILURE
+        )
+
+        # Test with None/unset value
+        options = WorkflowStateOptions()
+        result = _to_idl_state_options(False, options, {})
+        # By default, wait_until_api_failure_policy should not be set when proceed_to_execute_when_wait_until_retry_exhausted is None
+        # The DEX service will use FAIL_WORKFLOW_ON_FAILURE by default
+        from dex.dex_api.types import Unset
+
+        self.assertTrue(isinstance(result.wait_until_api_failure_policy, Unset))
+
+    def test_proceed_on_failure(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(
+            StateOptionsWorkflow1,
+            wf_id,
+            10,
+            "input",
+            WorkflowOptions(workflow_id_reuse_policy=IDReusePolicy.DISALLOW_REUSE),
+        )
+        output = self.client.wait_for_workflow_completion(wf_id)
+
+        assert output == "InitState1_execute_completed"
+
+    def test_fail_workflow_on_failure(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(
+            StateOptionsWorkflow2,
+            wf_id,
+            10,
+            "input",
+            WorkflowOptions(workflow_id_reuse_policy=IDReusePolicy.DISALLOW_REUSE),
+        )
+
+        with self.assertRaises(WorkflowFailed):
+            self.client.wait_for_workflow_completion(wf_id, str)

dex/tests/test_workflow_state_options_override.py

@@ -0,0 +1,44 @@
+# 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.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.workflow_options import WorkflowOptions
+
+from dex.dex_api.models import IDReusePolicy
+from dex.tests.worker_server import registry
+
+from dex.tests.workflows.state_options_override_workflow import (
+    StateOptionsOverrideWorkflow,
+)
+
+class TestStateOptionsOverrideWorkflow(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_override(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(
+            StateOptionsOverrideWorkflow,
+            wf_id,
+            10,
+            "input",
+            WorkflowOptions(workflow_id_reuse_policy=IDReusePolicy.DISALLOW_REUSE),
+        )
+        output = self.client.wait_for_workflow_completion(wf_id)
+
+        assert (
+            output
+            == "input_InitState_waitUntil_completed_InitState_execute_completed_NonInitState_execute_completed"
+        )

dex/tests/worker_server.py

@@ -0,0 +1,64 @@
+# 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 threading import Thread
+
+from flask import Flask, request
+
+from dex.dex_api.models import (
+    WorkflowStateExecuteRequest,
+    WorkflowStateWaitUntilRequest,
+    WorkflowWorkerRpcRequest,
+)
+from dex.tests import registry
+from dex.worker_service import (
+    WorkerService,
+)
+
+# NOTE: set this to true when debugging(using breakpoints)
+# so that it keep the thread running so that we can see the error in history
+debug_mode: bool = False
+
+_flask_app = Flask(__name__)
+
+_worker_service = WorkerService(registry)
+
+@_flask_app.route("/")
+def index():
+    return "hello"
+
+@_flask_app.route(WorkerService.api_path_workflow_state_wait_until, methods=["POST"])
+def handle_wait_until():
+    req = WorkflowStateWaitUntilRequest.from_dict(request.json)
+    resp = _worker_service.handle_workflow_state_wait_until(req)
+    return resp.to_dict()
+
+@_flask_app.route(WorkerService.api_path_workflow_state_execute, methods=["POST"])
+def handle_execute():
+    req = WorkflowStateExecuteRequest.from_dict(request.json)
+    resp = _worker_service.handle_workflow_state_execute(req)
+    return resp.to_dict()
+
+@_flask_app.route(WorkerService.api_path_workflow_worker_rpc, methods=["POST"])
+def handle_rpc():
+    req = WorkflowWorkerRpcRequest.from_dict(request.json)
+    resp = _worker_service.handle_workflow_worker_rpc(req)
+    return resp.to_dict()
+
+# this handler is extremely useful for debugging Dex
+# the WebUI will be able to show you the error with stacktrace
+@_flask_app.errorhandler(Exception)
+def internal_error(exception):
+    return _worker_service.handle_worker_error(exception), 500
+
+_webApp = Thread(target=_flask_app.run, args=("0.0.0.0", 8802))
+# when debugging, keep the thread running so that we can see the error in history
+_webApp.setDaemon(not debug_mode)
+_webApp.start()

dex/tests/workflows/abnormal_exit_workflow.py

@@ -0,0 +1,42 @@
+# 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 typing import Union
+
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.dex_api.models import RetryPolicy
+from dex.persistence import Persistence
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState
+from dex.workflow_state_options import WorkflowStateOptions
+
+class AbnormalExitState1(WorkflowState[Union[int, str]]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        raise RuntimeError("abnormal exit state")
+
+    def get_state_options(self) -> WorkflowStateOptions:
+        return WorkflowStateOptions(
+            execute_api_retry_policy=RetryPolicy(maximum_attempts=1)
+        )
+
+class AbnormalExitWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(AbnormalExitState1())

dex/tests/workflows/basic_workflow.py

@@ -0,0 +1,62 @@
+# 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 typing import Union
+
+from dex.command_request import CommandRequest, TimerCommand
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.persistence import Persistence
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState
+
+class State1(WorkflowState[Union[int, str]]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        if input != "input":
+            raise RuntimeError("input is incorrect")
+        return CommandRequest.for_all_command_completed(
+            TimerCommand.by_seconds(1),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        if input != "input":
+            raise RuntimeError("input is incorrect")
+        return StateDecision.single_next_state(State2)
+
+class State2(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.graceful_complete_workflow("done")
+
+class BasicWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(State1(), State2())

dex/tests/workflows/conditional_complete_workflow.py

@@ -0,0 +1,95 @@
+# 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.
+
+import time
+
+from dex.command_request import (
+    CommandRequest,
+    InternalChannelCommand,
+    SignalChannelCommand,
+)
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.communication_schema import CommunicationMethod, CommunicationSchema
+from dex.persistence import Persistence
+from dex.persistence_schema import PersistenceField, PersistenceSchema
+from dex.rpc import rpc
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState
+
+test_signal_channel = "test-1"
+test_internal_channel = "test-2"
+
+da_counter = "counter"
+
+class WaitState(WorkflowState[bool]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        use_signal: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        if use_signal:
+            return CommandRequest.for_all_command_completed(
+                SignalChannelCommand.by_name(test_signal_channel),
+            )
+        else:
+            return CommandRequest.for_all_command_completed(
+                InternalChannelCommand.by_name(test_internal_channel),
+            )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        use_signal: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        counter = persistence.get_data_attribute(da_counter)
+        if counter is None:
+            counter = 0
+        counter += 1
+        persistence.set_data_attribute(da_counter, counter)
+
+        if ctx.state_execution_id == "WaitState-1":
+            # wait for 3 seconds so that the channel can have a new message
+            time.sleep(3)
+        if use_signal:
+            return StateDecision.force_complete_if_signal_channel_empty_or_else(
+                test_signal_channel, counter, WaitState, use_signal
+            )
+        else:
+            return StateDecision.force_complete_if_internal_channel_empty_or_else(
+                test_internal_channel, counter, WaitState, use_signal
+            )
+
+class ConditionalCompleteWorkflow(ObjectWorkflow):
+    def get_communication_schema(self) -> CommunicationSchema:
+        return CommunicationSchema.create(
+            CommunicationMethod.signal_channel_def(test_signal_channel, int),
+            CommunicationMethod.internal_channel_def(test_internal_channel, int),
+        )
+
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.data_attribute_def(da_counter, int),
+        )
+
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(WaitState())
+
+    @rpc()
+    def test_rpc_publish_channel(self, com: Communication):
+        com.publish_to_internal_channel(test_internal_channel, 0)

dex/tests/workflows/describe_workflow.py

@@ -0,0 +1,46 @@
+# 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.command_request import CommandRequest, TimerCommand
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.persistence import Persistence
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState
+
+class WaitState(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.for_all_command_completed(
+            TimerCommand.by_seconds(10),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+
+        return StateDecision.graceful_complete_workflow()
+
+class DescribeWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(WaitState())

dex/tests/workflows/empty_data_workflow.py

@@ -0,0 +1,45 @@
+# 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.command_results import CommandResults
+from dex.communication import Communication
+from dex.persistence import Persistence
+from dex.persistence_schema import PersistenceField, PersistenceSchema
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import WorkflowState
+
+TEST_DA_KEY = "test-da"
+
+class State1(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: None,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        assert input is None
+        test_da = persistence.get_data_attribute(TEST_DA_KEY)
+        assert test_da is None
+
+        return StateDecision.graceful_complete_workflow(output="success")
+
+class EmptyDataWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(State1())
+
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.data_attribute_def(TEST_DA_KEY, None),
+        )

dex/tests/workflows/internal_channel_workflow.py

@@ -0,0 +1,129 @@
+# 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.command_request import CommandRequest, InternalChannelCommand
+from dex.command_results import CommandResults, InternalChannelCommandResult
+from dex.communication import Communication
+from dex.communication_schema import CommunicationMethod, CommunicationSchema
+from dex.dex_api.models import ChannelRequestStatus
+from dex.persistence import Persistence
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState
+
+test_channel_name1 = "test-internal-channel-1"
+test_channel_name2 = "test-internal-channel-2"
+
+test_channel_name3 = "test-internal-channel-3"
+test_channel_name4 = "test-internal-channel-4"
+
+test_channel_name_prefix = "test-internal-channel-prefix-"
+
+class InitState(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.multi_next_states(
+            WaitAnyWithPublishState, WaitAllThenPublishState
+        )
+
+class WaitAnyWithPublishState(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        communication.publish_to_internal_channel(test_channel_name3, 123)
+        communication.publish_to_internal_channel(test_channel_name4, "str-value")
+        communication.publish_to_internal_channel(
+            test_channel_name_prefix + "abc", "str-value-for-prefix"
+        )
+        return CommandRequest.for_any_command_completed(
+            InternalChannelCommand.by_name(test_channel_name1),
+            InternalChannelCommand.by_name(test_channel_name2),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        assert len(command_results.internal_channel_commands) == 2
+        assert command_results.internal_channel_commands[
+            0
+        ] == InternalChannelCommandResult(
+            channel_name=test_channel_name1,
+            command_id="",
+            status=ChannelRequestStatus.WAITING,
+            value=None,
+        )
+        assert command_results.internal_channel_commands[
+            1
+        ] == InternalChannelCommandResult(
+            channel_name=test_channel_name2,
+            command_id="",
+            status=ChannelRequestStatus.RECEIVED,
+            value=None,
+        )
+        return StateDecision.graceful_complete_workflow()
+
+class WaitAllThenPublishState(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.for_all_command_completed(
+            InternalChannelCommand.by_name(test_channel_name3),
+            InternalChannelCommand.by_name(test_channel_name4),
+            InternalChannelCommand.by_name(test_channel_name_prefix + "abc"),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        communication.publish_to_internal_channel(test_channel_name2, None)
+        return StateDecision.dead_end
+
+class InternalChannelWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(
+            InitState(), WaitAnyWithPublishState(), WaitAllThenPublishState()
+        )
+
+    def get_communication_schema(self) -> CommunicationSchema:
+        return CommunicationSchema.create(
+            CommunicationMethod.internal_channel_def(test_channel_name1, int),
+            CommunicationMethod.internal_channel_def(test_channel_name2, None),
+            CommunicationMethod.internal_channel_def(test_channel_name3, int),
+            CommunicationMethod.internal_channel_def(test_channel_name4, str),
+            CommunicationMethod.internal_channel_def_by_prefix(
+                test_channel_name_prefix, str
+            ),
+        )