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

dex/tests/workflows/java_duplicate_rpc_memo_workflow.py

@@ -0,0 +1,285 @@
+# 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
+
+
+"""
+NOTE: This workflow and its tests were translated from dex-java-sdk, but currently, there is a
+discrepency between the sdks in their handling of empty graceful complete workflow
+messages. These tests will not pass, so they are curretly being skipped. They were added
+here for posterity.
+"""
+
+
+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 JavaDuplicateRpcMemoWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(
+            RpcMemoWorkflowState1(), RpcMemoWorkflowState2()
+        )
+
+    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)
+        communication.trigger_state_execution(RpcMemoWorkflowState2)
+        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)
+        communication.trigger_state_execution(RpcMemoWorkflowState2)
+        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)
+        communication.trigger_state_execution(RpcMemoWorkflowState2)
+
+    @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)
+        communication.trigger_state_execution(RpcMemoWorkflowState2)
+
+    @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.single_next_state(RpcMemoWorkflowState2, 0)
+
+
+class RpcMemoWorkflowState2(WorkflowState[int]):
+    _counter: int = 0
+
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: int,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.empty()
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: int,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        self._counter += 1
+        if self._counter == 2:
+            return StateDecision.graceful_complete_workflow(self._counter)
+        else:
+            return StateDecision.graceful_complete_workflow()
+
+    @classmethod
+    def reset_counter(cls) -> int:
+        old = cls._counter
+        cls._counter = 0
+        return old

dex/tests/workflows/persistence_data_attributes_workflow.py

@@ -0,0 +1,104 @@
+# 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 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 T, WorkflowState
+
+initial_da_1 = "initial_da_1"
+initial_da_value_1 = "value_1"
+initial_da_2 = "initial_da_2"
+initial_da_value_2 = "value_2"
+
+test_da_1 = "test_da_1"
+test_da_2 = "test_da_2"
+
+final_test_da_value_1 = "1234"
+final_test_da_value_2 = 1234
+final_initial_da_value_1 = initial_da_value_1
+final_initial_da_value_2 = "no-more-init"
+
+test_da_prefix = "test-da-prefix"
+test_da_prefix_key_1 = "test-da-prefix-1"
+test_da_prefix_key_2 = "test-da-prefix-2"
+test_da_prefix_value_1 = "test-da-value-1"
+test_da_prefix_value_2 = "test-da-value-2"
+test_da_set_key = "test_da_set_key"
+test_da_set_value = "test_da_set_value"
+
+expected_final_das = {
+    initial_da_1: initial_da_value_1,
+    initial_da_2: final_initial_da_value_2,
+    test_da_1: final_test_da_value_1,
+    test_da_2: final_test_da_value_2,
+    test_da_prefix_key_1: test_da_prefix_value_1,
+    test_da_prefix_key_2: test_da_prefix_value_2,
+    test_da_set_key: test_da_set_value,
+}
+
+
+class DataAttributeRWState(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        persistence.set_data_attribute(test_da_1, "123")
+        persistence.set_data_attribute(test_da_2, 123)
+
+        return CommandRequest.empty()
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        da1 = persistence.get_data_attribute(test_da_1)
+        da2 = persistence.get_data_attribute(test_da_2)
+        assert da1 == "123"
+        assert da2 == 123
+
+        persistence.set_data_attribute(test_da_1, final_test_da_value_1)
+        persistence.set_data_attribute(test_da_2, final_test_da_value_2)
+        persistence.set_data_attribute(initial_da_2, final_initial_da_value_2)
+        persistence.set_data_attribute(test_da_prefix_key_1, test_da_prefix_value_1)
+        persistence.set_data_attribute(test_da_prefix_key_2, test_da_prefix_value_2)
+        return StateDecision.graceful_complete_workflow()
+
+
+class PersistenceDataAttributesWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(DataAttributeRWState())
+
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.data_attribute_def(initial_da_1, str),
+            PersistenceField.data_attribute_def(initial_da_2, str),
+            PersistenceField.data_attribute_def(test_da_1, str),
+            PersistenceField.data_attribute_def(test_da_2, int),
+            PersistenceField.data_attribute_prefix_def(test_da_prefix, str),
+            PersistenceField.data_attribute_def(test_da_set_key, str),
+        )

dex/tests/workflows/persistence_search_attributes_workflow.py

@@ -0,0 +1,167 @@
+# 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 time import sleep
+
+from dex.command_request import CommandRequest, TimerCommand
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.dex_api.models import SearchAttributeValueType
+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 T, WorkflowState
+
+sa_keyword_key = "CustomKeywordField"
+sa_double_key = "CustomDoubleField"
+sa_int_key = "CustomIntField"
+sa_bool_key = "CustomBoolField"
+sa_datetime_key = "CustomDatetimeField"
+sa_keyword_array_key = "CustomKeywordArrayField"
+
+initial_sa_keyword: str = "initial_keyword"
+initial_sa_double: float = 1.11
+initial_sa_int: int = 1
+initial_sa_bool: bool = True
+initial_sa_datetime: str = "2024-11-09T16:00:01.731455544-08:00"
+initial_sa_keyword_array: list[str] = ["initial_keyword-1", "initial_keyword-2"]
+
+sa_keyword: str = "keyword"
+sa_double: float = 2.34
+sa_int: int = 234
+sa_bool: bool = False
+sa_datetime: str = "2024-11-12T16:00:01.731455544-08:00"
+sa_keyword_array: list[str] = ["keyword-1", "keyword-2"]
+
+final_sa_keyword: str = "final_keyword"
+final_sa_int: int = 567
+final_sa_bool: bool = False
+final_sa_datetime: str = "2024-12-13T16:00:01.731455544-08:00"
+final_sa_keyword_array: list[str] = ["final_keyword-1", "final_keyword-2"]
+
+
+class SearchAttributeStateInit(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.for_all_command_completed(
+            TimerCommand.by_seconds(2),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        persistence.set_search_attribute_keyword(sa_keyword_key, sa_keyword)
+        persistence.set_search_attribute_double(sa_double_key, sa_double)
+        persistence.set_search_attribute_boolean(sa_bool_key, sa_bool)
+        persistence.set_search_attribute_keyword_array(
+            sa_keyword_array_key, sa_keyword_array
+        )
+        persistence.set_search_attribute_int64(sa_int_key, sa_int)
+        persistence.set_search_attribute_datetime(sa_datetime_key, sa_datetime)
+        return StateDecision.single_next_state(SearchAttributeState1)
+
+
+class SearchAttributeState1(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.for_all_command_completed(
+            TimerCommand.by_seconds(2),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.single_next_state(SearchAttributeState2)
+
+
+class SearchAttributeState2(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        return CommandRequest.empty()
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        # Delay updating search attributes to allow for the previous assertion
+        sleep(1)
+        persistence.set_search_attribute_keyword(sa_keyword_key, final_sa_keyword)
+        persistence.set_search_attribute_boolean(sa_bool_key, final_sa_bool)
+        persistence.set_search_attribute_keyword_array(
+            sa_keyword_array_key, final_sa_keyword_array
+        )
+        persistence.set_search_attribute_int64(sa_int_key, final_sa_int)
+        persistence.set_search_attribute_datetime(sa_datetime_key, final_sa_datetime)
+        return StateDecision.graceful_complete_workflow()
+
+
+class PersistenceSearchAttributesWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(
+            SearchAttributeStateInit(), SearchAttributeState1(), SearchAttributeState2()
+        )
+
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.search_attribute_def(
+                sa_keyword_key, SearchAttributeValueType.KEYWORD
+            ),
+            PersistenceField.search_attribute_def(
+                sa_double_key, SearchAttributeValueType.DOUBLE
+            ),
+            PersistenceField.search_attribute_def(
+                sa_bool_key, SearchAttributeValueType.BOOL
+            ),
+            PersistenceField.search_attribute_def(
+                sa_keyword_array_key, SearchAttributeValueType.KEYWORD_ARRAY
+            ),
+            PersistenceField.search_attribute_def(
+                sa_int_key, SearchAttributeValueType.INT
+            ),
+            PersistenceField.search_attribute_def(
+                sa_datetime_key, SearchAttributeValueType.DATETIME
+            ),
+        )

dex/tests/workflows/persistence_state_execution_local_workflow.py

@@ -0,0 +1,69 @@
+# 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.rpc import rpc
+from dex.command_request import CommandRequest
+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 T, WorkflowState
+
+PERSISTENCE_LOCAL_KEY = "persistence-test-key"
+PERSISTENCE_LOCAL_VALUE = "persistence-test-value"
+PERSISTENCE_DATA_ATTRIBUTE_KEY = "persistence-data-attribute-key"
+
+
+class PersistenceStateExecutionLocalRWState(WorkflowState[None]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        persistence.set_state_execution_local(
+            PERSISTENCE_LOCAL_KEY, PERSISTENCE_LOCAL_VALUE
+        )
+        return CommandRequest.empty()
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ):
+        value = persistence.get_state_execution_local(PERSISTENCE_LOCAL_KEY)
+        persistence.set_data_attribute(PERSISTENCE_DATA_ATTRIBUTE_KEY, value)
+        return StateDecision.graceful_complete_workflow()
+
+
+class PersistenceStateExecutionLocalWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(PersistenceStateExecutionLocalRWState())
+
+    def get_persistence_schema(self) -> PersistenceSchema:
+        return PersistenceSchema.create(
+            PersistenceField.data_attribute_def(PERSISTENCE_DATA_ATTRIBUTE_KEY, str)
+        )
+
+    @rpc()
+    def test_persistence_read(self, persistence: Persistence):
+        return persistence.get_data_attribute(PERSISTENCE_DATA_ATTRIBUTE_KEY)