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

dex/tests/test_conditional_complete.py

@@ -0,0 +1,50 @@
+# 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.tests.worker_server import registry
+from dex.tests.workflows.conditional_complete_workflow import (
+    ConditionalCompleteWorkflow,
+    test_signal_channel,
+)
+
+class TestConditionalComplete(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_internal_channel_conditional_complete(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        do_test_conditional_workflow(self.client, wf_id, False)
+
+    def test_signal_channel_conditional_complete(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        do_test_conditional_workflow(self.client, wf_id, True)
+
+def do_test_conditional_workflow(client: Client, wf_id: str, use_signal: bool):
+    client.start_workflow(ConditionalCompleteWorkflow, wf_id, 10, use_signal)
+
+    for x in range(3):
+        if use_signal:
+            client.signal_workflow(wf_id, test_signal_channel, 123)
+        else:
+            client.invoke_rpc(
+                wf_id, ConditionalCompleteWorkflow.test_rpc_publish_channel
+            )
+        if x == 0:
+            # wait for a second so that the workflow is in execute state
+            time.sleep(1)
+
+    res = client.wait_for_workflow_completion(wf_id)
+    assert res == 3

dex/tests/test_describe_workflow.py

@@ -0,0 +1,40 @@
+# 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.errors import WorkflowNotExistsError
+from dex.dex_api.models import WorkflowStatus
+from dex.tests.workflows.describe_workflow import DescribeWorkflow
+from dex.tests.worker_server import registry
+
+class TestDescribeWorkflow(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_describe_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        self.client.start_workflow(DescribeWorkflow, wf_id, 100)
+        workflow_info = self.client.describe_workflow(wf_id)
+        assert workflow_info.workflow_status == WorkflowStatus.RUNNING
+
+        # Stop the workflow
+        self.client.stop_workflow(wf_id)
+
+    def test_describe_workflow_when_workflow_not_exists(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        with self.assertRaises(WorkflowNotExistsError):
+            self.client.describe_workflow(wf_id)

dex/tests/test_empty_data_decodes_properly.py

@@ -0,0 +1,74 @@
+# 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
+
+import httpx
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.worker_service import WorkerService
+
+class TestBinaryNullDecodesCorrectly(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_binary_null_input_decodes_correctly(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        response = httpx.post(
+            f"http://0.0.0.0:8802/{WorkerService.api_path_workflow_state_execute}",
+            json={
+                "DataObjects": [
+                    {"key": "test-da", "value": {"encoding": "binary/null"}}
+                ],
+                "commandResults": {
+                    "interStateChannelResults": [],
+                    "stateStartApiSucceeded": True,
+                },
+                "context": {
+                    "attempt": 1,
+                    "firstAttemptTimestamp": 1747935829,
+                    "stateExecutionId": "State1-1",
+                    "workflowId": wf_id,
+                    "workflowRunId": "0196f734-d037-7432-bd63-e1136cd34dbd",
+                    "workflowStartedTimestamp": 1747904155,
+                },
+                "stateInput": {"encoding": "binary/null"},
+                "stateLocals": [],
+                "workflowStateId": "State1",
+                "workflowType": "EmptyDataWorkflow",
+            },
+        )
+        assert response.is_success
+        response_json = response.json()
+        self.assertEqual(
+            response_json,
+            {
+                "publishToInterStateChannel": [],
+                "recordEvents": [],
+                "stateDecision": {
+                    "nextStates": [
+                        {
+                            "stateId": "_SYS_GRACEFUL_COMPLETING_WORKFLOW",
+                            "stateInput": {
+                                "data": '"success"',
+                                "encoding": "json/plain",
+                            },
+                        }
+                    ]
+                },
+                "upsertDataObjects": [],
+                "upsertStateLocals": [],
+            },
+        )

dex/tests/test_internal_channel.py

@@ -0,0 +1,28 @@
+# 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.tests.worker_server import registry
+from dex.tests.workflows.internal_channel_workflow import InternalChannelWorkflow
+
+class TestConditionalComplete(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_internal_channel_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        self.client.start_workflow(InternalChannelWorkflow, wf_id, 100, None)
+        self.client.wait_for_workflow_completion(wf_id, None)

dex/tests/test_internal_channel_with_no_prefix_channel.py

@@ -0,0 +1,41 @@
+# 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.tests.worker_server import registry
+from dex.tests.workflows.internal_channel_workflow_with_no_prefix_channel import (
+    InternalChannelWorkflowWithNoPrefixChannel,
+    test_non_prefix_channel_name_with_suffix,
+)
+
+class TestInternalChannelWithNoPrefix(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_internal_channel_workflow_with_no_prefix_channel(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        self.client.start_workflow(
+            InternalChannelWorkflowWithNoPrefixChannel, wf_id, 5, None
+        )
+
+        with self.assertRaises(Exception) as context:
+            self.client.wait_for_workflow_completion(wf_id, None)
+
+        self.assertIn("FAILED", context.exception.workflow_status)
+        self.assertIn(
+            f"WorkerExecutionError: InternalChannel channel_name is not defined {test_non_prefix_channel_name_with_suffix}",
+            context.exception.error_message,
+        )

dex/tests/test_persistence_data_attributes.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.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.tests.workflows.persistence_data_attributes_workflow import (
+    PersistenceDataAttributesWorkflow,
+    initial_da_1,
+    initial_da_2,
+    initial_da_value_2,
+    initial_da_value_1,
+    test_da_set_key,
+    test_da_set_value,
+    expected_final_das,
+)
+from dex.workflow_options import WorkflowOptions
+
+class TestPersistenceDataAttributes(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_persistence_data_attributes_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        start_options = WorkflowOptions(
+            initial_data_attributes={
+                initial_da_1: initial_da_value_1,
+                initial_da_2: initial_da_value_2,
+            },
+        )
+
+        wf_run_id = self.client.start_workflow(
+            PersistenceDataAttributesWorkflow, wf_id, 100, None, start_options
+        )
+        self.client.set_workflow_data_attributes(
+            PersistenceDataAttributesWorkflow,
+            wf_id,
+            wf_run_id,
+            {
+                test_da_set_key: test_da_set_value,
+            },
+        )
+        self.client.wait_for_workflow_completion(wf_id, None)
+
+        all_data_attributes = self.client.get_all_workflow_data_attributes(
+            PersistenceDataAttributesWorkflow, wf_id, wf_run_id
+        )
+        for k, v in expected_final_das.items():
+            assert k in all_data_attributes
+            assert all_data_attributes[k] == v

dex/tests/test_persistence_search_attributes.py

@@ -0,0 +1,127 @@
+# 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.tests.worker_server import registry
+from dex.tests.workflows.persistence_search_attributes_workflow import (
+    PersistenceSearchAttributesWorkflow,
+    sa_keyword_key,
+    sa_double_key,
+    sa_int_key,
+    sa_bool_key,
+    sa_datetime_key,
+    sa_keyword_array_key,
+    initial_sa_keyword,
+    initial_sa_double,
+    initial_sa_int,
+    initial_sa_bool,
+    initial_sa_datetime,
+    initial_sa_keyword_array,
+    SearchAttributeState1,
+    sa_keyword,
+    sa_double,
+    sa_bool,
+    sa_keyword_array,
+    sa_int,
+    final_sa_keyword,
+    final_sa_bool,
+    final_sa_int,
+    final_sa_keyword_array,
+)
+from dex.workflow_options import WorkflowOptions
+
+class TestPersistenceSearchAttributes(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_persistence_search_attributes_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        wf_opts = WorkflowOptions(
+            initial_search_attributes={
+                sa_keyword_key: initial_sa_keyword,
+                sa_double_key: initial_sa_double,
+                sa_int_key: initial_sa_int,
+                sa_bool_key: initial_sa_bool,
+                sa_datetime_key: initial_sa_datetime,
+                sa_keyword_array_key: initial_sa_keyword_array,
+            }
+        )
+        wf_opts.add_wait_for_completion_state_ids(SearchAttributeState1)
+        self.client.start_workflow(
+            PersistenceSearchAttributesWorkflow, wf_id, 100, None, wf_opts
+        )
+
+        initial_returned_search_attributes = self.client.get_all_search_attributes(
+            PersistenceSearchAttributesWorkflow,
+            wf_id,
+        )
+
+        initial_expected_search_attributes = dict()
+        initial_expected_search_attributes[sa_keyword_key] = initial_sa_keyword
+        initial_expected_search_attributes[sa_double_key] = initial_sa_double
+        initial_expected_search_attributes[sa_bool_key] = initial_sa_bool
+        initial_expected_search_attributes[sa_keyword_array_key] = (
+            initial_sa_keyword_array
+        )
+        initial_expected_search_attributes[sa_int_key] = initial_sa_int
+        initial_expected_search_attributes[sa_datetime_key] = (
+            "2024-11-10T00:00:01.731455544Z"  # This is a bug. The dex-server always returns utc time. See https://github.com/superdurable/dex/issues/261
+            # "2024-11-09T18:00:01.731455544-06:00"
+        )
+
+        assert initial_expected_search_attributes == initial_returned_search_attributes
+
+        self.client.wait_for_state_execution_completion_with_state_execution_id(
+            SearchAttributeState1, wf_id
+        )
+
+        returned_search_attributes = self.client.get_all_search_attributes(
+            PersistenceSearchAttributesWorkflow,
+            wf_id,
+        )
+
+        expected_search_attributes = dict()
+        expected_search_attributes[sa_keyword_key] = sa_keyword
+        expected_search_attributes[sa_double_key] = sa_double
+        expected_search_attributes[sa_bool_key] = sa_bool
+        expected_search_attributes[sa_keyword_array_key] = sa_keyword_array
+        expected_search_attributes[sa_int_key] = sa_int
+        expected_search_attributes[sa_datetime_key] = (
+            "2024-11-13T00:00:01.731455544Z"  # This is a bug. The dex-server always returns utc time. See https://github.com/superdurable/dex/issues/261
+            # "2024-11-12T18:00:01.731455544-06:00"
+        )
+
+        assert expected_search_attributes == returned_search_attributes
+
+        self.client.wait_for_workflow_completion(wf_id)
+
+        final_expected_search_attributes = dict()
+        final_expected_search_attributes[sa_keyword_key] = final_sa_keyword
+        final_expected_search_attributes[sa_double_key] = sa_double
+        final_expected_search_attributes[sa_int_key] = final_sa_int
+        final_expected_search_attributes[sa_bool_key] = final_sa_bool
+        final_expected_search_attributes[sa_keyword_array_key] = final_sa_keyword_array
+        final_expected_search_attributes[sa_datetime_key] = (
+            "2024-12-14T00:00:01.731455544Z"  # This is a bug. The dex-server always returns utc time. See https://github.com/superdurable/dex/issues/261
+            # "2024-12-13T18:00:01.731455544-06:00"
+        )
+
+        final_returned_search_attributes = self.client.get_all_search_attributes(
+            PersistenceSearchAttributesWorkflow,
+            wf_id,
+        )
+
+        assert final_expected_search_attributes == final_returned_search_attributes

dex/tests/test_persistence_state_execution_locals.py

@@ -0,0 +1,38 @@
+# 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.tests.worker_server import registry
+from dex.tests.workflows.persistence_state_execution_local_workflow import (
+    PersistenceStateExecutionLocalWorkflow,
+    PERSISTENCE_LOCAL_VALUE,
+)
+from dex.workflow_options import WorkflowOptions
+
+class TestPersistenceExecutionLocalRead(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_persistence_execution_local_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        start_options = WorkflowOptions()
+        self.client.start_workflow(
+            PersistenceStateExecutionLocalWorkflow, wf_id, 200, None, start_options
+        )
+        self.client.wait_for_workflow_completion(wf_id, None)
+        res = self.client.invoke_rpc(
+            wf_id, PersistenceStateExecutionLocalWorkflow.test_persistence_read
+        )
+        assert res == PERSISTENCE_LOCAL_VALUE

dex/tests/test_rpc.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.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.tests.workflows.rpc_workflow import RPCWorkflow, Mydata
+
+class TestRPCs(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_simple_rpc(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(RPCWorkflow, wf_id, 10)
+
+        input = Mydata("test", 100)
+        output = self.client.invoke_rpc(
+            wf_id, RPCWorkflow.test_rpc_input_type, input, Mydata
+        )
+        assert output == input
+
+        output = self.client.invoke_rpc(wf_id, RPCWorkflow.test_simple_rpc)
+        assert output == 123
+        wf = RPCWorkflow()
+        output = self.client.invoke_rpc(wf_id, wf.test_simple_rpc)
+        assert output == 123
+
+    def test_complicated_rpc(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(RPCWorkflow, wf_id, 10)
+        self.client.invoke_rpc(wf_id, RPCWorkflow.test_rpc_persistence_write, 100)
+        res = self.client.invoke_rpc(wf_id, RPCWorkflow.test_rpc_persistence_read)
+        assert res == 100
+        self.client.invoke_rpc(wf_id, RPCWorkflow.test_rpc_trigger_state, 200)
+        res = self.client.invoke_rpc(wf_id, RPCWorkflow.test_rpc_persistence_read)
+        assert res == 200
+
+        res1 = self.client.invoke_rpc(
+            wf_id, RPCWorkflow.test_rpc_publish_to_idle_channel, "input-1"
+        )
+        # Channel Size should be 1
+        assert res1 == 1
+
+        res2 = self.client.invoke_rpc(
+            wf_id, RPCWorkflow.test_rpc_publish_to_idle_channel, "input-2"
+        )
+        # Channel Size should be 2
+        assert res2 == 2
+
+        self.client.invoke_rpc(wf_id, RPCWorkflow.test_rpc_publish_channel)
+        result = self.client.wait_for_workflow_completion(wf_id, str)
+        assert result == "done"