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

dex/communication_schema.py

@@ -0,0 +1,54 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional, Union
+
+class CommunicationMethodType(Enum):
+    SignalChannel = 1
+    InternalChannel = 2
+
+@dataclass
+class CommunicationMethod:
+    name: str
+    method_type: CommunicationMethodType
+    value_type: Optional[type]
+    is_prefix: bool
+
+    @classmethod
+    def signal_channel_def(cls, name: str, value_type: Union[type, None]):
+        return CommunicationMethod(
+            name,
+            CommunicationMethodType.SignalChannel,
+            value_type if value_type is not None else type(None),
+            False,
+        )
+
+    @classmethod
+    def internal_channel_def(cls, name: str, value_type: Union[type, None]):
+        return CommunicationMethod(
+            name,
+            CommunicationMethodType.InternalChannel,
+            value_type if value_type is not None else type(None),
+            False,
+        )
+
+    @classmethod
+    def internal_channel_def_by_prefix(
+        cls, name_prefix: str, value_type: Union[type, None]
+    ):
+        return CommunicationMethod(
+            name_prefix,
+            CommunicationMethodType.InternalChannel,
+            value_type if value_type is not None else type(None),
+            True,
+        )
+
+@dataclass
+class CommunicationSchema:
+    communication_methods: List[CommunicationMethod] = field(default_factory=list)
+
+    @classmethod
+    def create(cls, *methods: CommunicationMethod):
+        return CommunicationSchema(list(methods))

dex/condition.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.
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+from typing import TYPE_CHECKING, Generic, TypeVar
+
+from dex._utils import validate_condition_id
+
+if TYPE_CHECKING:
+    from dex.channel import Channel, ChannelMap
+
+ValueT = TypeVar("ValueT")
+
+
+@dataclass(frozen=True)
+class Condition:
+    condition_id: str | None = None
+
+    def __post_init__(self) -> None:
+        validate_condition_id(self.condition_id)
+
+
+@dataclass(frozen=True)
+class TimerCondition(Condition):
+    duration: timedelta = timedelta(0)
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        if self.duration < timedelta(0):
+            raise ValueError("timer duration must not be negative")
+
+
+@dataclass(frozen=True)
+class ChannelCondition(Condition, Generic[ValueT]):
+    channel: Channel[ValueT] | ChannelMap[ValueT] | None = None
+    instance: str | None = None
+    at_least: int | None = None
+    at_most: int | None = None
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        if self.channel is None:
+            raise ValueError("channel condition requires a channel")
+        if self.at_least is None and self.at_most is None:
+            raise ValueError("channel condition requires a bound")
+        if self.at_least is not None and self.at_least < 0:
+            raise ValueError("at_least must not be negative")
+        if self.at_most is not None and self.at_most < 0:
+            raise ValueError("at_most must not be negative")
+        if (
+            self.at_least is not None
+            and self.at_most is not None
+            and self.at_most < self.at_least
+        ):
+            raise ValueError("at_most must not be below at_least")
+
+
+@dataclass(frozen=True)
+class ConditionCombination:
+    conditions: tuple[Condition, ...]
+
+    @staticmethod
+    def of(*conditions: Condition) -> ConditionCombination:
+        return ConditionCombination(conditions)

dex/context.py

@@ -0,0 +1,86 @@
+# 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 typing import TYPE_CHECKING, Protocol, Sequence, TypeVar
+
+if TYPE_CHECKING:
+    from dex.attribute import Attribute, AttributeMap
+    from dex.channel import Channel, ChannelMap
+
+ValueT = TypeVar("ValueT")
+
+
+class Context(Protocol):
+    @property
+    def flow_id(self) -> str: ...
+
+    @property
+    def run_id(self) -> str: ...
+
+    @property
+    def step_execution_id(self) -> str: ...
+
+    @property
+    def from_step_execution_id(self) -> str: ...
+
+    @property
+    def attempt(self) -> int: ...
+
+    def has_timer_fired(self, index: int | None = None) -> bool: ...
+
+    def wait_for_method_failed(self) -> bool: ...
+
+    def set_step_execution_local(self, key: str, value: object) -> None: ...
+
+    def get_step_execution_local(
+        self, key: str, value_type: type[ValueT]
+    ) -> ValueT | None: ...
+
+    def record_event(self, name: str, value: object) -> None: ...
+
+    def _get_attribute(
+        self,
+        definition: Attribute[ValueT] | AttributeMap[ValueT],
+        instance: str | None,
+    ) -> ValueT: ...
+
+    def _set_attribute(
+        self,
+        definition: Attribute[ValueT] | AttributeMap[ValueT],
+        instance: str | None,
+        value: ValueT,
+    ) -> None: ...
+
+    def _delete_attribute(
+        self,
+        definition: Attribute[object] | AttributeMap[object],
+        instance: str | None,
+    ) -> None: ...
+
+    def _publish_channel(
+        self,
+        definition: Channel[ValueT] | ChannelMap[ValueT],
+        instance: str | None,
+        value: ValueT,
+    ) -> None: ...
+
+    def _channel_size(
+        self,
+        definition: Channel[object] | ChannelMap[object],
+        instance: str | None,
+    ) -> int: ...
+
+    def _channel_results(
+        self,
+        definition: Channel[ValueT] | ChannelMap[ValueT],
+        instance: str | None,
+    ) -> Sequence[ValueT]: ...

dex/data_attributes.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.
+
+from typing import Any, Union
+
+from dex.errors import WorkflowDefinitionError
+from dex.dex_api.models import EncodedObject
+from dex.dex_api.types import Unset
+from dex.object_encoder import ObjectEncoder
+from dex.type_store import TypeStore
+
+class DataAttributes:
+    _type_store: TypeStore
+    _object_encoder: ObjectEncoder
+    _current_values: dict[str, Union[EncodedObject, None, Unset]]
+    _updated_values_to_return: dict[str, Union[EncodedObject, Unset]]
+
+    def __init__(
+        self,
+        type_store: TypeStore,
+        object_encoder: ObjectEncoder,
+        current_values: dict[str, Union[EncodedObject, None, Unset]],
+    ):
+        self._object_encoder = object_encoder
+        self._type_store = type_store
+        self._current_values = current_values
+        self._updated_values_to_return = {}
+
+    def get_data_attribute(self, key: str) -> Any:
+        is_registered = self._type_store.is_valid_name_or_prefix(key)
+        if not is_registered:
+            raise WorkflowDefinitionError(f"data attribute %s is not registered {key}")
+
+        encoded_object = self._current_values.get(key)
+        if encoded_object is None:
+            return None
+
+        registered_type = self._type_store.get_type(key)
+        return self._object_encoder.decode(encoded_object, registered_type)
+
+    def set_data_attribute(self, key: str, value: Any):
+        is_registered = self._type_store.is_valid_name_or_prefix(key)
+        if not is_registered:
+            raise WorkflowDefinitionError(
+                f"data attribute {key} is not registered {key}"
+            )
+
+        registered_type = self._type_store.get_type(key)
+        if (
+            value is not None
+            and registered_type is not None
+            and not isinstance(value, registered_type)
+        ):
+            raise WorkflowDefinitionError(
+                f"data attribute {key} is of the right type {registered_type}"
+            )
+
+        encoded_value = self._object_encoder.encode(value)
+        self._current_values[key] = encoded_value
+        self._updated_values_to_return[key] = encoded_value
+
+    def get_updated_values_to_return(self) -> dict[str, Union[EncodedObject, Unset]]:
+        return self._updated_values_to_return

dex/dexpb/__init__.py

@@ -0,0 +1 @@
+# Generated package for Dex protobuf stubs.