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

dex/tests/workflows/conditional_complete_workflow.py

@@ -0,0 +1,101 @@
+# 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 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,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[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,51 @@
+# 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.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,137 @@
+# 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, 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
+            ),
+        )

dex/tests/workflows/internal_channel_workflow_with_no_prefix_channel.py

@@ -0,0 +1,108 @@
+# 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, 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.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
+
+internal_channel_name = "internal-channel-1"
+
+test_non_prefix_channel_name = "test-channel-"
+test_non_prefix_channel_name_with_suffix = test_non_prefix_channel_name + "abc"
+
+
+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:
+        # Trying to publish to a non-existing channel; this would only work if test_channel_name_non_prefix was defined as a prefix channel
+        communication.publish_to_internal_channel(
+            test_non_prefix_channel_name_with_suffix, "str-value-for-prefix"
+        )
+        return CommandRequest.for_any_command_completed(
+            InternalChannelCommand.by_name(internal_channel_name),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        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_non_prefix_channel_name),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        communication.publish_to_internal_channel(internal_channel_name, None)
+        return StateDecision.dead_end
+
+
+class InternalChannelWorkflowWithNoPrefixChannel(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(internal_channel_name, None),
+            # Defining a standard channel (non-prefix) to make sure messages to the channel with a suffix added will not be accepted
+            CommunicationMethod.internal_channel_def(test_non_prefix_channel_name, str),
+        )