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

dex/step.py

@@ -0,0 +1,194 @@
+# 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 __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, replace
+from datetime import timedelta
+from enum import Enum
+from typing import Any, Generic, Iterator, TypeVar
+
+from dex.attribute import AttributeLock
+from dex.channel import Channel, ChannelMap
+from dex.context import Context
+from dex.wait import Wait
+
+InputT = TypeVar("InputT")
+StartT = TypeVar("StartT")
+
+
+class StepDurability(Enum):
+    DEFAULT = "default"
+    SYNC = "sync"
+    ASYNC = "async"
+
+
+class WaitForFailurePolicy(Enum):
+    FAIL_FLOW = "fail_flow"
+    PROCEED = "proceed"
+
+
+@dataclass(frozen=True)
+class RetryPolicy:
+    initial_interval: timedelta | None = None
+    backoff_coefficient: float = 0.0
+    maximum_interval: timedelta | None = None
+    maximum_attempts: int = 0
+    total_duration: timedelta | None = None
+
+
+@dataclass(frozen=True)
+class StepOptions:
+    wait_for_method_timeout: timedelta | None = None
+    execute_method_timeout: timedelta | None = None
+    wait_for_retry: RetryPolicy | None = None
+    execute_retry: RetryPolicy | None = None
+    wait_for_failure: WaitForFailurePolicy = WaitForFailurePolicy.FAIL_FLOW
+    wait_for_durability: StepDurability = StepDurability.DEFAULT
+    execute_durability: StepDurability = StepDurability.DEFAULT
+    wait_for_lock_attributes: tuple[AttributeLock, ...] = ()
+    execute_lock_attributes: tuple[AttributeLock, ...] = ()
+    _execute_failure_target: Step[Any] | None = None
+    _execute_failure_options: StepOptions | None = None
+
+    def on_execute_failure_proceed_to(
+        self,
+        step: Step[Any],
+        options: StepOptions | None = None,
+    ) -> StepOptions:
+        return replace(
+            self,
+            _execute_failure_target=step,
+            _execute_failure_options=options,
+        )
+
+
+class Step(Generic[InputT], ABC):
+    @abstractmethod
+    def execute(
+        self,
+        context: Context,
+        input: InputT,
+    ) -> StepDecision:
+        raise NotImplementedError
+
+    def wait_for(self, context: Context, input: InputT) -> Wait:
+        del context, input
+        raise RuntimeError("framework must skip the default wait_for")
+
+    def get_step_type(self) -> str:
+        return type(self).__name__
+
+    def get_step_options(self) -> StepOptions | None:
+        return None
+
+
+@dataclass(frozen=True)
+class _StepDef:
+    step: Step[Any]
+    is_start_step: bool
+
+
+@dataclass(frozen=True)
+class StepList(Generic[StartT]):
+    _definitions: tuple[_StepDef, ...]
+
+    @classmethod
+    def empty(cls) -> StepList[StartT]:
+        return cls(())
+
+    @staticmethod
+    def start_step(step: Step[StartT]) -> StepList[StartT]:
+        return StepList((_StepDef(step, True),))
+
+    @classmethod
+    def without_start_step(cls, *steps: Step[Any]) -> StepList[StartT]:
+        return cls(tuple(_StepDef(step, False) for step in steps))
+
+    def other_steps(self, *steps: Step[Any]) -> StepList[StartT]:
+        return StepList(
+            self._definitions + tuple(_StepDef(step, False) for step in steps)
+        )
+
+    def __iter__(self) -> Iterator[_StepDef]:
+        return iter(self._definitions)
+
+
+@dataclass(frozen=True)
+class StepMovement(Generic[InputT]):
+    step: Step[InputT]
+    input: InputT
+    options: StepOptions | None = None
+
+    @staticmethod
+    def of(
+        step: Step[InputT],
+        input: InputT,
+        *,
+        options: StepOptions | None = None,
+    ) -> StepMovement[InputT]:
+        return StepMovement(step, input, options)
+
+
+class DecisionKind(Enum):
+    NEXT = "next"
+    GRACEFUL_COMPLETE = "graceful_complete"
+    FORCE_COMPLETE = "force_complete"
+    FORCE_COMPLETE_IF_CHANNELS_EMPTY = "force_complete_if_channels_empty"
+    FORCE_FAIL = "force_fail"
+    DEAD_END = "dead_end"
+
+
+@dataclass(frozen=True)
+class StepDecision:
+    kind: DecisionKind
+    movements: tuple[StepMovement[Any], ...] = ()
+    output: object | None = None
+    reason: str = ""
+    empty_channels: tuple[Channel[Any] | ChannelMap[Any], ...] = ()
+    fallback: StepMovement[Any] | None = None
+
+
+def go_to(step: Step[InputT], input: InputT) -> StepDecision:
+    return go_to_multi(StepMovement.of(step, input))
+
+
+def go_to_multi(*movements: StepMovement[Any]) -> StepDecision:
+    return StepDecision(DecisionKind.NEXT, movements=movements)
+
+
+def graceful_complete(output: object | None = None) -> StepDecision:
+    return StepDecision(DecisionKind.GRACEFUL_COMPLETE, output=output)
+
+
+def force_complete(output: object | None = None) -> StepDecision:
+    return StepDecision(DecisionKind.FORCE_COMPLETE, output=output)
+
+
+def force_complete_when_channels_empty(
+    output: object,
+    fallback: StepMovement[Any],
+    *channels: Channel[Any] | ChannelMap[Any],
+) -> StepDecision:
+    return StepDecision(
+        DecisionKind.FORCE_COMPLETE_IF_CHANNELS_EMPTY,
+        output=output,
+        empty_channels=channels,
+        fallback=fallback,
+    )
+
+
+def force_fail(reason: str) -> StepDecision:
+    return StepDecision(DecisionKind.FORCE_FAIL, reason=reason)
+
+
+def dead_end() -> StepDecision:
+    return StepDecision(DecisionKind.DEAD_END)

dex/step_execution.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 __future__ import annotations
+
+from dataclasses import dataclass
+
+from dex._utils import require_name
+
+
+@dataclass(frozen=True)
+class StepExecutionId:
+    step_type: str
+    number: int = 1
+
+
+@dataclass(frozen=True)
+class TimerId:
+    condition_id: str | None = None
+    condition_index: int | None = None
+
+    def __post_init__(self) -> None:
+        if (self.condition_id is None) == (self.condition_index is None):
+            raise ValueError("TimerId requires exactly one selector")
+        if self.condition_index is not None and self.condition_index < 0:
+            raise ValueError("timer condition index must not be negative")
+
+    @staticmethod
+    def by_condition_id(condition_id: str) -> TimerId:
+        require_name(condition_id)
+        return TimerId(condition_id=condition_id)
+
+    @staticmethod
+    def by_condition_index(condition_index: int) -> TimerId:
+        return TimerId(condition_index=condition_index)

dex/stop_workflow_options.py

@@ -0,0 +1,18 @@
+# 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 dataclasses import dataclass
+
+from dex.dex_api.models import WorkflowStopType
+
+@dataclass
+class StopWorkflowOptions:
+    workflow_stop_type: WorkflowStopType
+    reason: str

dex/tests/__init__.py

@@ -0,0 +1,80 @@
+# 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.registry import Registry
+from dex.tests.workflows.abnormal_exit_workflow import AbnormalExitWorkflow
+from dex.tests.workflows.basic_workflow import BasicWorkflow
+from dex.tests.workflows.conditional_complete_workflow import (
+    ConditionalCompleteWorkflow,
+)
+from dex.tests.workflows.describe_workflow import DescribeWorkflow
+from dex.tests.workflows.empty_data_workflow import EmptyDataWorkflow
+from dex.tests.workflows.internal_channel_workflow import InternalChannelWorkflow
+from dex.tests.workflows.internal_channel_workflow_with_no_prefix_channel import (
+    InternalChannelWorkflowWithNoPrefixChannel,
+)
+from dex.tests.workflows.java_duplicate_rpc_memo_workflow import (
+    JavaDuplicateRpcMemoWorkflow,
+)
+from dex.tests.workflows.persistence_data_attributes_workflow import (
+    PersistenceDataAttributesWorkflow,
+)
+from dex.tests.workflows.persistence_search_attributes_workflow import (
+    PersistenceSearchAttributesWorkflow,
+)
+from dex.tests.workflows.persistence_state_execution_local_workflow import (
+    PersistenceStateExecutionLocalWorkflow,
+)
+from dex.tests.workflows.recovery_workflow import RecoveryWorkflow
+from dex.tests.workflows.rpc_memo_workflow import RpcMemoWorkflow
+from dex.tests.workflows.rpc_workflow import RPCWorkflow
+from dex.tests.workflows.state_options_override_workflow import (
+    StateOptionsOverrideWorkflow,
+)
+from dex.tests.workflows.state_options_workflow import (
+    StateOptionsWorkflow1,
+    StateOptionsWorkflow2,
+)
+from dex.tests.workflows.timer_workflow import TimerWorkflow
+from dex.tests.workflows.wait_for_state_with_state_execution_id_workflow import (
+    WaitForStateWithStateExecutionIdWorkflow,
+)
+from dex.tests.workflows.wait_for_state_with_wait_for_key_workflow import (
+    WaitForStateWithWaitForKeyWorkflow,
+)
+from dex.tests.workflows.wait_internal_channel_workflow import (
+    WaitInternalChannelWorkflow,
+)
+from dex.tests.workflows.wait_signal_workflow import WaitSignalWorkflow
+
+registry = Registry()
+
+registry.add_workflow(AbnormalExitWorkflow())
+registry.add_workflow(BasicWorkflow())
+registry.add_workflow(ConditionalCompleteWorkflow())
+registry.add_workflow(DescribeWorkflow())
+registry.add_workflow(EmptyDataWorkflow())
+registry.add_workflow(InternalChannelWorkflow())
+registry.add_workflow(InternalChannelWorkflowWithNoPrefixChannel())
+registry.add_workflow(JavaDuplicateRpcMemoWorkflow())
+registry.add_workflow(PersistenceDataAttributesWorkflow())
+registry.add_workflow(PersistenceSearchAttributesWorkflow())
+registry.add_workflow(PersistenceStateExecutionLocalWorkflow())
+registry.add_workflow(RecoveryWorkflow())
+registry.add_workflow(RpcMemoWorkflow())
+registry.add_workflow(RPCWorkflow())
+registry.add_workflow(StateOptionsOverrideWorkflow())
+registry.add_workflow(StateOptionsWorkflow1())
+registry.add_workflow(StateOptionsWorkflow2())
+registry.add_workflow(TimerWorkflow())
+registry.add_workflow(WaitForStateWithStateExecutionIdWorkflow())
+registry.add_workflow(WaitForStateWithWaitForKeyWorkflow())
+registry.add_workflow(WaitInternalChannelWorkflow())
+registry.add_workflow(WaitSignalWorkflow())

dex/tests/dex-service-env/.env

@@ -0,0 +1,7 @@
+CASSANDRA_VERSION=3.11.9
+ELASTICSEARCH_VERSION=7.17.27
+MYSQL_VERSION=8
+POSTGRESQL_VERSION=13
+TEMPORAL_VERSION=1.25
+TEMPORAL_UI_VERSION=2.31.2
+TEMPORAL_ADMIN_TOOLS_VERSION=1.25.2-tctl-1.18.1-cli-1.1.1

dex/tests/dex-service-env/docker-compose-init.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+checkExists () {
+  # see https://github.com/temporalio/temporal/issues/4160
+  if temporal  operator search-attribute list | grep -q "$1"; then
+    return 0
+  else
+    return 1
+fi
+}
+
+echo "now trying to register Dex system search attributes..."
+for run in {1..120}; do
+  sleep 1
+  temporal  operator search-attribute  create --name DexWorkflowType --type Keyword
+  sleep 0.1
+  temporal  operator search-attribute  create --name DexGlobalWorkflowVersion --type Int
+  sleep 0.1
+  temporal  operator search-attribute  create --name DexExecutingStateIds --type KeywordList
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomKeywordField --type Keyword
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomIntField --type Int
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomBoolField --type Bool
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomDoubleField --type Double
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomDatetimeField --type Datetime
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomStringField --type Text
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomKeywordArrayField --type KeywordList
+  sleep 0.1
+
+  if checkExists "DexWorkflowType" && checkExists "DexGlobalWorkflowVersion" && checkExists "DexExecutingStateIds" && checkExists "CustomKeywordField" && checkExists "CustomIntField" && checkExists "CustomBoolField" && checkExists "CustomDoubleField" && checkExists "CustomDatetimeField" && checkExists "CustomStringField" && checkExists "CustomKeywordArrayField"; then
+    echo "All search attributes are registered"
+    break
+  fi
+
+done
+
+
+tail -f /dev/null

dex/tests/dex-service-env/docker-compose.yml

@@ -0,0 +1,97 @@
+# 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.
+
+version: '3.9'
+
+# see .env file for the default value of the environment variables
+services:
+  elasticsearch:
+    container_name: temporal-elasticsearch-dex
+    environment:
+    - cluster.routing.allocation.disk.threshold_enabled=true
+    - cluster.routing.allocation.disk.watermark.low=512mb
+    - cluster.routing.allocation.disk.watermark.high=256mb
+    - cluster.routing.allocation.disk.watermark.flood_stage=128mb
+    - discovery.type=single-node
+    - ES_JAVA_OPTS=-Xms512m -Xmx512m
+    - xpack.security.enabled=false
+    image: elasticsearch:${ELASTICSEARCH_VERSION}
+    networks:
+    - temporal-network
+    expose:
+    - 9200
+  postgresql:
+    container_name: temporal-postgresql-dex
+    environment:
+      POSTGRES_PASSWORD: temporal
+      POSTGRES_USER: temporal
+    image: postgres:${POSTGRESQL_VERSION}
+    networks:
+    - temporal-network
+    expose:
+    - 5432
+  temporal:
+    container_name: temporal-dex
+    depends_on:
+    - postgresql
+    - elasticsearch
+    environment:
+    - DB=postgres12
+    - DB_PORT=5432
+    - POSTGRES_USER=temporal
+    - POSTGRES_PWD=temporal
+    - POSTGRES_SEEDS=postgresql
+    - DYNAMIC_CONFIG_FILE_PATH=config/dynamicconfig/development-sql.yaml
+    - ENABLE_ES=true
+    - ES_SEEDS=elasticsearch
+    - ES_VERSION=v7
+    image: temporalio/auto-setup:${TEMPORAL_VERSION}
+    networks:
+    - temporal-network
+    ports:
+    - 7233:7233
+    labels:
+      kompose.volume.type: configMap
+    volumes:
+    - ./dynamicconfig:/etc/temporal/config/dynamicconfig
+  temporal-admin-tools:
+    container_name: temporal-admin-tools-dex
+    depends_on:
+    - temporal
+    environment:
+    - TEMPORAL_ADDRESS=temporal:7233
+    - TEMPORAL_CLI_ADDRESS=temporal:7233
+    image: temporalio/admin-tools:${TEMPORAL_ADMIN_TOOLS_VERSION}
+    networks:
+    - temporal-network
+    stdin_open: true
+    tty: true
+    volumes:
+    - ./docker-compose-init.sh:/etc/temporal/init.sh
+    entrypoint: sh -c "/etc/temporal/init.sh"
+  dex-server:
+    container_name: dex-server
+    image: ${DEX_SERVER_IMAGE:-superdurable/dex-server:latest}
+    environment:
+    # Replace localhost/127.0.0.1 worker URLs so the container can reach the host worker.
+    # host.docker.internal works on Docker Desktop and on Linux with extra_hosts below.
+    - AUTO_FIX_WORKER_URL=host.docker.internal
+    networks:
+    - temporal-network
+    ports:
+    - 8801:8801
+    depends_on:
+    - temporal
+    extra_hosts:
+    - host.docker.internal:host-gateway
+networks:
+  temporal-network:
+    driver: bridge
+    name: temporal-network

dex/tests/dex-service-env/dynamicconfig/README.md

@@ -0,0 +1,39 @@
+Use `docker.yaml` file to override the default dynamic config value (they are specified
+when creating the service config).
+
+Each key can have zero or more values and each value can have zero or more
+constraints. There are only three types of constraint:
+1. `namespace`: `string`
+2. `taskQueueName`: `string`
+3. `taskType`: `int` (`1`:`Workflow`, `2`:`Activity`)
+A value will be selected and returned if all its has exactly the same constraints
+as the ones specified in query filters (including the number of constraints).
+
+Please use the following format:
+```
+testGetBoolPropertyKey:
+  - value: false
+  - value: true
+    constraints:
+      namespace: "global-samples-namespace"
+  - value: false
+    constraints:
+      namespace: "samples-namespace"
+testGetDurationPropertyKey:
+  - value: "1m"
+    constraints:
+      namespace: "samples-namespace"
+      taskQueueName: "longIdleTimeTaskqueue"
+testGetFloat64PropertyKey:
+  - value: 12.0
+    constraints:
+      namespace: "samples-namespace"
+testGetMapPropertyKey:
+  - value:
+      key1: 1
+      key2: "value 2"
+      key3:
+        - false
+        - key4: true
+          key5: 2.0
+```

dex/tests/dex-service-env/dynamicconfig/development-sql.yaml

@@ -0,0 +1,9 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+limit.maxIDLength:
+- value: 255
+  constraints: {}
+system.forceSearchAttributesCacheRefreshOnRead:
+- value: true # Dev setup only. Please don't turn this on in production.
+  constraints: {}

dex/tests/dex-service-env/dynamicconfig/docker.yaml

@@ -0,0 +1,2 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.

dex/tests/test_abnormal_exit_workflow.py

@@ -0,0 +1,43 @@
+# 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 WorkflowFailed
+from dex.dex_api.models.id_reuse_policy import IDReusePolicy
+from dex.tests.worker_server import registry
+from dex.tests.workflows.abnormal_exit_workflow import AbnormalExitWorkflow
+from dex.tests.workflows.basic_workflow import BasicWorkflow
+from dex.workflow_options import WorkflowOptions
+
+class TestAbnormalWorkflow(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_abnormal_exit_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        start_options = WorkflowOptions(
+            workflow_id_reuse_policy=IDReusePolicy.ALLOW_IF_PREVIOUS_EXITS_ABNORMALLY
+        )
+
+        self.client.start_workflow(
+            AbnormalExitWorkflow, wf_id, 100, "input", start_options
+        )
+        with self.assertRaises(WorkflowFailed):
+            self.client.wait_for_workflow_completion(wf_id, str)
+
+        # Starting a workflow with the same ID should be allowed since the previous failed abnormally
+        self.client.start_workflow(BasicWorkflow, wf_id, 100, "input", start_options)
+        res = self.client.wait_for_workflow_completion(wf_id, str)
+        assert res == "done"

dex/tests/test_basic_workflow.py

@@ -0,0 +1,70 @@
+# 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 WorkflowAlreadyStartedError
+from dex.dex_api.models import WorkflowAlreadyStartedOptions
+from dex.tests.worker_server import registry
+from dex.tests.workflows.basic_workflow import BasicWorkflow
+from dex.workflow_options import WorkflowOptions
+
+class TestWorkflowErrors(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_basic_workflow(self):
+        original_request_id = "1"
+        later_request_id = "2"
+
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        workflow_already_started_options_1 = WorkflowAlreadyStartedOptions(
+            ignore_already_started_error=True
+        )
+        workflow_already_started_options_1.request_id = original_request_id
+
+        start_options_1 = WorkflowOptions()
+        start_options_1.workflow_already_started_options = (
+            workflow_already_started_options_1
+        )
+
+        wf_run_id = self.client.start_workflow(
+            BasicWorkflow, wf_id, 100, "input", start_options_1
+        )
+        assert wf_run_id
+
+        wf_run_id = self.client.start_workflow(
+            BasicWorkflow, wf_id, 100, "input", start_options_1
+        )
+        assert wf_run_id
+
+        workflow_already_started_options_2 = WorkflowAlreadyStartedOptions(
+            ignore_already_started_error=True
+        )
+        workflow_already_started_options_2.request_id = later_request_id
+
+        start_options_2 = WorkflowOptions()
+        start_options_2.workflow_already_started_option = (
+            workflow_already_started_options_2
+        )
+
+        with self.assertRaises(WorkflowAlreadyStartedError):
+            wf_run_id = self.client.start_workflow(
+                BasicWorkflow, wf_id, 100, "input", start_options_2
+            )
+            assert wf_run_id
+
+        res = self.client.wait_for_workflow_completion(wf_id, str)
+        assert res == "done"