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

dex/tests/workflows/recovery_workflow.py

@@ -0,0 +1,90 @@
+# 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 dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.dex_api.models import RetryPolicy
+from dex.dex_api.models.wait_until_api_failure_policy import WaitUntilApiFailurePolicy
+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 FailWaitUntilState(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        raise RuntimeError("failed wait_until")
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        return StateDecision.single_next_state(FailExecuteState)
+
+    def get_state_options(self) -> WorkflowStateOptions:
+        return WorkflowStateOptions(
+            execute_api_retry_policy=RetryPolicy(maximum_attempts=1),
+            wait_until_api_retry_policy=RetryPolicy(maximum_attempts=1),
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.PROCEED_ON_FAILURE,
+        )
+
+
+class FailExecuteState(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        raise RuntimeError("a random error to fail the state")
+
+    def get_state_options(self) -> WorkflowStateOptions:
+        return WorkflowStateOptions(
+            execute_api_retry_policy=RetryPolicy(maximum_attempts=1),
+            proceed_to_state_when_execute_retry_exhausted=RecoveryState,
+        )
+
+
+class RecoveryState(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.graceful_complete_workflow("done")
+
+
+class RecoveryWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(
+            FailWaitUntilState(), FailExecuteState(), RecoveryState()
+        )

dex/tests/workflows/rpc_memo_workflow.py

@@ -0,0 +1,238 @@
+# 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 Optional
+
+from dex.command_request import CommandRequest, InternalChannelCommand
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.communication_schema import CommunicationMethod, CommunicationSchema
+from dex.dex_api.models.search_attribute_value_type import SearchAttributeValueType
+from dex.persistence import Persistence
+from dex.persistence_options import PersistenceOptions
+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 WorkflowState
+
+
+INTERNAL_CHANNEL_NAME = "test-channel-1"
+TEST_DATA_OBJECT_KEY = "data-obj-1"
+TEST_SEARCH_ATTRIBUTE_KEY = "CustomKeywordField"
+TEST_SEARCH_ATTRIBUTE_INT = "CustomIntField"
+RPC_INPUT = "rpc-input"
+RPC_OUTPUT = 100
+TEST_STR = "test-str"
+TEST_DELAY = 0.1
+
+
+class RpcMemoWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(RpcMemoWorkflowState1())
+
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.data_attribute_def(TEST_DATA_OBJECT_KEY, str),
+            PersistenceField.search_attribute_def(
+                TEST_SEARCH_ATTRIBUTE_INT, SearchAttributeValueType.INT
+            ),
+            PersistenceField.search_attribute_def(
+                TEST_SEARCH_ATTRIBUTE_KEY, SearchAttributeValueType.KEYWORD
+            ),
+        )
+
+    def get_communication_schema(self) -> CommunicationSchema:
+        return CommunicationSchema.create(
+            CommunicationMethod.internal_channel_def(INTERNAL_CHANNEL_NAME, None)
+        )
+
+    def get_persistence_options(self) -> PersistenceOptions:
+        return PersistenceOptions(enable_caching=True)
+
+    @rpc()
+    def test_rpc_func1(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> int:
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+
+        persistence.set_data_attribute(TEST_DATA_OBJECT_KEY, None)
+        persistence.set_data_attribute(TEST_DATA_OBJECT_KEY, input)
+        persistence.set_search_attribute_keyword(TEST_SEARCH_ATTRIBUTE_KEY, input)
+        persistence.set_search_attribute_int64(TEST_SEARCH_ATTRIBUTE_INT, RPC_OUTPUT)
+        communication.publish_to_internal_channel(INTERNAL_CHANNEL_NAME, None)
+        return RPC_OUTPUT
+
+    @rpc()
+    def test_rpc_func0(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> int:
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+
+        persistence.set_data_attribute(TEST_DATA_OBJECT_KEY, TEST_STR)
+        persistence.set_search_attribute_keyword(TEST_SEARCH_ATTRIBUTE_KEY, TEST_STR)
+        persistence.set_search_attribute_int64(TEST_SEARCH_ATTRIBUTE_INT, RPC_OUTPUT)
+        communication.publish_to_internal_channel(INTERNAL_CHANNEL_NAME, None)
+        return RPC_OUTPUT
+
+    @rpc()
+    def test_rpc_proc1(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+
+        persistence.set_data_attribute(TEST_DATA_OBJECT_KEY, input)
+        persistence.set_search_attribute_keyword(TEST_SEARCH_ATTRIBUTE_KEY, input)
+        persistence.set_search_attribute_int64(TEST_SEARCH_ATTRIBUTE_INT, RPC_OUTPUT)
+        communication.publish_to_internal_channel(INTERNAL_CHANNEL_NAME, None)
+
+    @rpc()
+    def test_rpc_proc0(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+
+        persistence.set_data_attribute(TEST_DATA_OBJECT_KEY, TEST_STR)
+        persistence.set_search_attribute_keyword(TEST_SEARCH_ATTRIBUTE_KEY, TEST_STR)
+        persistence.set_search_attribute_int64(TEST_SEARCH_ATTRIBUTE_INT, RPC_OUTPUT)
+        communication.publish_to_internal_channel(INTERNAL_CHANNEL_NAME, None)
+
+    @rpc()
+    def test_rpc_func1_readonly(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> int:
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+        return RPC_OUTPUT
+
+    @rpc()
+    def test_rpc_set_data_attribute(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+        persistence.set_data_attribute(TEST_DATA_OBJECT_KEY, input)
+
+    @rpc()
+    def test_rpc_get_data_attribute(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> str:
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+        return persistence.get_data_attribute(TEST_DATA_OBJECT_KEY)
+
+    @rpc(bypass_caching_for_strong_consistency=True)
+    def test_rpc_get_data_attribute_strong_consistency(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> str:
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+        return persistence.get_data_attribute(TEST_DATA_OBJECT_KEY)
+
+    @rpc()
+    def test_rpc_set_keyword(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+        persistence.set_search_attribute_keyword(TEST_SEARCH_ATTRIBUTE_KEY, input)
+
+    @rpc(bypass_caching_for_strong_consistency=True)
+    def test_rpc_get_keyword_strong_consistency(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> Optional[str]:
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+        return persistence.get_search_attribute_keyword(TEST_SEARCH_ATTRIBUTE_KEY)
+
+    @rpc()
+    def test_rpc_get_keyword(
+        self,
+        ctx: WorkflowContext,
+        input: str,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> Optional[str]:
+        if not ctx.workflow_id or not ctx.workflow_run_id:
+            raise RuntimeError("invalid context")
+        return persistence.get_search_attribute_keyword(TEST_SEARCH_ATTRIBUTE_KEY)
+
+
+class RpcMemoWorkflowState1(WorkflowState[int]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: int,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.for_any_command_completed(
+            InternalChannelCommand.by_name(INTERNAL_CHANNEL_NAME)
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: int,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.graceful_complete_workflow()

dex/tests/workflows/rpc_workflow.py

@@ -0,0 +1,125 @@
+# 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 dex.command_request import CommandRequest, InternalChannelCommand
+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_data_attribute = "test-1"
+channel_name = "test-2"
+idle_channel_name = "test-3"
+
+
+@dataclass
+class Mydata:
+    strdata: str
+    intdata: int
+
+
+class WaitState(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.for_all_command_completed(
+            InternalChannelCommand.by_name(channel_name)
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.single_next_state(EndState)
+
+
+class EndState(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.graceful_complete_workflow("done")
+
+
+class RPCWorkflow(ObjectWorkflow):
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.data_attribute_def(test_data_attribute, int)
+        )
+
+    def get_communication_schema(self) -> CommunicationSchema:
+        return CommunicationSchema.create(
+            CommunicationMethod.internal_channel_def(channel_name, type(None)),
+            CommunicationMethod.internal_channel_def(idle_channel_name, str),
+        )
+
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.no_starting_state(WaitState(), EndState())
+
+    @rpc(timeout_seconds=100)
+    def test_simple_rpc(self):
+        return 123
+
+    @rpc()
+    def test_rpc_persistence_write(
+        self,
+        input: int,
+        persistence: Persistence,
+    ):
+        persistence.set_data_attribute(test_data_attribute, input)
+
+    @rpc()
+    def test_rpc_persistence_read(self, pers: Persistence):
+        return pers.get_data_attribute(test_data_attribute)
+
+    @rpc()
+    def test_rpc_trigger_state(self, pers: Persistence, com: Communication, i: int):
+        pers.set_data_attribute(test_data_attribute, i)
+        com.trigger_state_execution(WaitState)
+
+    @rpc()
+    def test_rpc_publish_channel(self, com: Communication):
+        com.publish_to_internal_channel(channel_name)
+
+    @rpc()
+    def test_rpc_publish_to_idle_channel(self, com: Communication, data: str):
+        com.publish_to_internal_channel(idle_channel_name, data)
+        return com.get_internal_channel_size(idle_channel_name)
+
+    @rpc()
+    def test_rpc_input_type(self, input: Mydata) -> Mydata:
+        if input.intdata != 100 or input.strdata != "test":
+            raise Exception("input type test failed")
+        return input

dex/tests/workflows/state_options_override_workflow.py

@@ -0,0 +1,100 @@
+# 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 dex.command_request import CommandRequest
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.persistence_schema import PersistenceSchema, PersistenceField
+
+from dex.dex_api.models import RetryPolicy, WaitUntilApiFailurePolicy
+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
+
+output_da = "output_da"
+
+
+class InitState(WorkflowState[str]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        persistence.set_data_attribute(
+            output_da, str(input) + "_InitState_waitUntil_completed"
+        )
+        return CommandRequest.empty()
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        data = persistence.get_data_attribute(output_da)
+        data += "_InitState_execute_completed"
+        return StateDecision.single_next_state(
+            NonInitState,
+            data,
+            WorkflowStateOptions(
+                wait_until_api_retry_policy=RetryPolicy(maximum_attempts=2),
+                proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.PROCEED_ON_FAILURE,
+            ),
+        )
+
+
+class NonInitState(WorkflowState[str]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        raise RuntimeError("test failure")
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        data = str(input) + "_NonInitState_execute_completed"
+        return StateDecision.graceful_complete_workflow(data)
+
+    def get_state_options(self) -> WorkflowStateOptions:
+        return WorkflowStateOptions(
+            wait_until_api_retry_policy=RetryPolicy(maximum_attempts=1),
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.FAIL_WORKFLOW_ON_FAILURE,
+        )
+
+
+class StateOptionsOverrideWorkflow(ObjectWorkflow):
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.data_attribute_def(output_da, str),
+        )
+
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(InitState(), NonInitState())

dex/tests/workflows/state_options_workflow.py

@@ -0,0 +1,92 @@
+# 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 dex.command_request import CommandRequest
+from dex.command_results import CommandResults
+from dex.communication import Communication
+
+from dex.dex_api.models import RetryPolicy, WaitUntilApiFailurePolicy
+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 InitState1(WorkflowState[str]):
+    def get_state_options(self) -> WorkflowStateOptions:
+        return WorkflowStateOptions(
+            wait_until_api_retry_policy=RetryPolicy(maximum_attempts=1),
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.PROCEED_ON_FAILURE,
+        )
+
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        raise RuntimeError("test failure")
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        data = "InitState1_execute_completed"
+        return StateDecision.graceful_complete_workflow(data)
+
+
+class InitState2(WorkflowState[str]):
+    def get_state_options(self) -> WorkflowStateOptions:
+        return WorkflowStateOptions(
+            wait_until_api_retry_policy=RetryPolicy(maximum_attempts=1),
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.FAIL_WORKFLOW_ON_FAILURE,
+        )
+
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        raise RuntimeError("test failure")
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        data = "InitState2_execute_completed"
+        return StateDecision.graceful_complete_workflow(data)
+
+
+class StateOptionsWorkflow1(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(InitState1())
+
+
+class StateOptionsWorkflow2(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(InitState2())

dex/tests/workflows/timer_workflow.py

@@ -0,0 +1,52 @@
+# 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 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[int]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: int,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.for_all_command_completed(
+            TimerCommand.by_seconds(input * 3600),
+            TimerCommand.by_seconds(input),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.graceful_complete_workflow()
+
+
+class TimerWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(WaitState())