dex-python-sdk 0.0.2__tar.gz → 0.1.2__tar.gz

dex_python_sdk-0.1.2/PKG-INFO

@@ -0,0 +1,295 @@
+Metadata-Version: 2.4
+Name: dex-python-sdk
+Version: 0.1.2
+Requires-Dist: grpcio>=1.83.0
+Requires-Dist: grpcio-status>=1.83.0
+Requires-Dist: protobuf>=7.35.1
+License-File: LICENSE
+License-File: LEGACY_NOTICES.md
+Summary: Python SDK for the Dex workflow engine
+Author: Super Durable
+License-Expression: LicenseRef-Super-Durable-1.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/superdurable/dex/tree/main/sdk-python
+Project-URL: Repository, https://github.com/superdurable/dex
+
+
+# Dex SDK for Python
+
+Python SDK for [Dex workflow engine](https://github.com/superdurable/dex)
+
+## New user contracts
+
+The rewrite targets Python 3.11+ and exposes strongly typed workflow contracts
+from `dex`. This phase includes definitions, attributes, channels, waits,
+decisions, codecs, registry validation, synchronous client calls, and synchronous
+worker handlers. Python owns its gRPC Client and Worker transport;
+the shared Rust Core is used only for BlobCache.
+
+```python
+from datetime import timedelta
+
+import dex
+
+counter = dex.Attribute("counter", int)
+counters_by_region = dex.AttributeMap("counters-by-region", int)
+
+class Run(dex.Step[str]):
+    def wait_for(
+        self, context: dex.Context, input: str
+    ) -> dex.Wait:
+        return dex.Wait.until(
+            dex.Timer.by_duration(timedelta(seconds=1))
+        )
+
+    def execute(
+        self, context: dex.Context, input: str
+    ) -> dex.StepDecision:
+        return dex.graceful_complete(input)
+
+class CounterFlow(dex.Flow[str]):
+    run = Run()
+
+    def get_flow_type(self) -> str:
+        return "Counter"
+
+    def get_steps(self) -> dex.StepList[str]:
+        return dex.StepList.start_step(self.run)
+
+    def get_persistence_schema(self) -> dex.PersistenceSchema:
+        return dex.PersistenceSchema.of(counter, counters_by_region)
+
+    @dex.rpc(name="Increment")
+    def increment(
+        self, context: dex.Context, input: int
+    ) -> dex.RPCResult[int]:
+        return dex.RPCResult(input + 1)
+
+flow = CounterFlow()
+registry = dex.Registry((flow,))
+```
+
+Registry derives codecs from declared Python types and handler annotations.
+Built-in scalar types and dataclasses need no codec arguments. Register an
+explicit codec only for a custom encoding or a type Registry cannot derive.
+`PersistenceSchema.of(...)` accepts attributes and channels together and
+partitions them by definition type.
+
+`Worker` and `AsyncWorker` synchronize all registered Indexed Attributes with
+Dex Server before opening their listener. Existing indexes return immediately;
+failure or the default two-minute deadline aborts startup. An indexed
+`AttributeMap` must provide one fixed `index_key`.
+
+Initial attributes retain their value types without a public wrapper class:
+
+```python
+options = (
+    dex.StartFlowOptions()
+    .with_attribute(counter, 1)
+    .with_attribute(counters_by_region, "us-west", 1)
+)
+```
+
+Opt in when declaring an Attribute or AttributeMap, and select the Store in
+Flow configuration:
+
+```python
+email = dex.Attribute("customer-email", str, sync_to_attribute_store=True)
+config = dex.FlowConfig(attribute_store_name="profiles")
+```
+
+The Store is an asynchronous latest-state projection. Deletion writes SQL
+`NULL`, and projection failures do not roll back Flow Attributes. `None`
+preserves the current target; an explicit empty string disables future
+synchronization while retaining protocol presence.
+
+```
+pip install dex-python-sdk==0.1.0
+```
+
+See [samples](../examples/python) for use case examples.
+
+## Requirements
+
+- Python 3.11+
+- [Dex server](https://github.com/superdurable/dex#how-to-use)
+
+## Concepts
+
+Applications implement two generic interfaces from [`dex`](dex/):
+
+- `Flow[START_INPUT]` returns `StepList.start_step(...)`, followed by optional
+  `.other_steps(...)`, from one `get_steps()` method. The `StepList` generic
+  binds the Flow input to the starting Step input. Use `StepList.empty()` when
+  a Flow has no Steps.
+- `Step[INPUT]` implements `execute` and optionally `wait_for`. The default
+  Worker path requires synchronous handlers. With `AsyncWorker` and
+  `Registry(..., allow_async_handlers=True)`, handlers may be `async def` and
+  `await` an `AsyncClient`.
+
+`StepOptions.wait_for_method_timeout` and `execute_method_timeout` bound the
+two handler calls. Timer and channel conditions determine how long a Step waits.
+
+`Registry` validates every Flow, Step, RPC signature, durable name, lock, and
+codec before Client or Worker startup. `Client` methods use these typed objects
+instead of raw Flow, Step, or RPC strings.
+
+### Errors
+
+Client calls raise concrete `DexServiceError` subclasses. Existing-Flow reads
+(`get_attribute`, `describe_flow`, `wait_for_flow`, and `reset_flow`) raise
+`FlowNotFoundError` when the Flow does not exist. Mutations, RPCs, timer/Step
+waits, config updates, and continue-as-new triggers raise
+`FlowNotActiveError` when no running Flow can accept the operation.
+
+```python
+try:
+    client.publish(flow_id, orders.approved, order_id)
+except dex.FlowNotActiveError:
+    # The Flow is missing or already closed.
+    pass
+```
+
+Duplicate starts, worker failures, RPC lock contention, and long-poll timeouts
+raise `FlowAlreadyStartedError`, `WorkerInvocationError`,
+`RpcLockConflictError`, and `LongPollTimeoutError`. All service errors retain
+`code`, `sub_status`, `detail`, `operation`, `flow_id`, and the original gRPC
+exception through Python exception chaining. Worker failures also expose
+`worker_code`, `worker_error_type`, and `worker_error_detail`. Registration,
+serialization, and invalid handler returns use `FlowDefinitionError`,
+`ValueMappingError`, and `InvalidStepResultError`.
+
+### Sync vs asyncio
+
+- **Sync (default):** `Client` and `Worker` use blocking gRPC and a thread-pool
+  Worker. Blocking `Client` calls inside `Step.execute` are safe (one pool
+  thread is occupied; other RPCs still run).
+- **Asyncio:** `AsyncClient` and `AsyncWorker` use `grpc.aio`. Use
+  `Registry(..., allow_async_handlers=True)` when Steps/RPCs are coroutines.
+  Inside async `execute`, inject `AsyncClient` — do not call sync `Client` on
+  the Worker event loop. Sync `Worker` still rejects coroutine handlers at
+  registry construction unless `allow_async_handlers=True` (and even then the
+  sync Worker dispatcher rejects awaitable return values).
+
+Integration scenarios live under
+[`tests/integ`](tests/integ/README.md). They exercise the same workflows,
+client operations, and assertions as the Java suite against an isolated
+`dexcli dev` environment.
+
+## Implementation status
+
+The strongly typed contracts, registry, synchronous Client/Worker, optional
+`AsyncClient`/`AsyncWorker` (`grpc.aio`), and Rust-backed BlobCache are
+implemented. Python owns its gRPC transport; the native bridge is limited to
+the shared BlobCache. Design notes:
+[`docs/design/plan/python-sdk-async-apis.md`](../docs/design/plan/python-sdk-async-apis.md).
+
+## Running dex-server locally
+
+### Option 1: use docker compose
+See [dex README](https://github.com/superdurable/dex#using-docker-image--docker-compose)
+
+### Option 2: VSCode Dev Container
+
+Dev Container is an easy way to get dex-server running locally. Follow these steps to launch a dev container:
+- Install Docker, VSCode, and [VSCode Dev Container plugin](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers).
+- Open the project in VSCode.
+    ```bash
+    cd dex-python-sdk
+    code .
+    ```
+- Launch the Remote-Containers: Reopen in Container command from Command Palette (Ctrl + Shift + P). You can also click in the bottom left corner to access the remote container menu.
+- Once the dev container starts, dex-server will be listening on port 8801.
+
+## How To Contribute
+
+This project uses [uv](https://docs.astral.sh/uv/) for Python versions,
+dependencies, virtual environments, locking, building, and publishing.
+
+To install requirements:
+
+```bash
+uv sync --locked
+```
+
+Run the complete Python SDK integration suite with an isolated Dex development
+environment:
+
+```bash
+./run-integration-tests.sh
+```
+
+### Measure integration coverage
+
+Run the same integration suite with Python source coverage:
+
+```bash
+./run-integration-tests.sh --coverage
+```
+
+Only the integration scenarios contribute execution data, and only production
+Python modules under `dex` are measured. Generated protobuf modules under
+`dex/dexpb` are excluded. The
+terminal report lists uncovered line ranges. The browser report starts at
+`coverage/html/index.html`; `coverage/coverage.xml` and `coverage/lcov.info`
+are also generated.
+
+CI uploads LCOV to Codecov with GitHub OIDC under the
+`sdk-python-integration` flag and retains the full report as the
+`sdk-python-integration-coverage` Actions artifact.
+
+#### Update IDL
+
+Edit [`protos/dex.proto`](../protos/dex.proto). Rename catalog: [`docs/design/idl-renames.md`](../docs/design/idl-renames.md).
+
+#### Generate stubs from IDL
+
+```bash
+make -C ../protos proto-python
+```
+
+Checked-in Python stubs land in `dex/dexpb/`.
+#### Linting
+
+Validate that every `dex.__all__` class, function, constant, public method,
+argument, return value, dataclass field, enum value, and public instance
+attribute has a Google-style docstring:
+
+```bash
+uv run --frozen python scripts/check_public_docs.py
+```
+
+The checker resolves definitions from the public package export table, so
+private helpers and generated protobuf modules are excluded. Use `help(dex.Client)`
+or IDE hover information to read the same documentation. To run all other
+linting for this project:
+
+```bash
+uv run --frozen pre-commit run --show-diff-on-failure --color=always --all-files
+```
+
+## Code of Conduct
+This project is governed by the [Contributor Covenant v 1.4.1](CODE_OF_CONDUCT.md). (Review the Code of Conduct and remove this sentence before publishing your project.)
+
+## Publishing to PyPI
+
+1. Optionally run **Publish Python SDK to PyPI** via workflow_dispatch with a version and
+   `publish=false` to validate all distributions without uploading.
+2. Create a GitHub Release with tag `sdk-python/vX.Y.Z` (for example `sdk-python/v0.1.0`).
+   CI stamps that version into `pyproject.toml` for the build (same idea as the TypeScript
+   SDK release), then builds and smoke-tests Linux x86_64/ARM64, macOS x86_64/ARM64, and
+   Windows x86_64 wheels, verifies the source distribution, and publishes with `PYPI_TOKEN`.
+3. After publishing, bump the committed `pyproject.toml` / docs install line when you want
+   the repo tip to reflect the released version.
+
+A manual run publishes only from `main`, and only when `publish` is explicitly selected.
+The dispatch `version` input is stamped the same way as a release tag.
+
+See [CONTRIBUTING.md](../CONTRIBUTING.md#releases-monorepo-tags) for monorepo tag conventions.
+
+## License
+
+[Super Durable Source License 1.0](LICENSE), with legacy portions under their
+original terms as described in [LEGACY_NOTICES.md](LEGACY_NOTICES.md).
+

dex_python_sdk-0.1.2/README.md

@@ -0,0 +1,278 @@
+
+# Dex SDK for Python
+
+Python SDK for [Dex workflow engine](https://github.com/superdurable/dex)
+
+## New user contracts
+
+The rewrite targets Python 3.11+ and exposes strongly typed workflow contracts
+from `dex`. This phase includes definitions, attributes, channels, waits,
+decisions, codecs, registry validation, synchronous client calls, and synchronous
+worker handlers. Python owns its gRPC Client and Worker transport;
+the shared Rust Core is used only for BlobCache.
+
+```python
+from datetime import timedelta
+
+import dex
+
+counter = dex.Attribute("counter", int)
+counters_by_region = dex.AttributeMap("counters-by-region", int)
+
+class Run(dex.Step[str]):
+    def wait_for(
+        self, context: dex.Context, input: str
+    ) -> dex.Wait:
+        return dex.Wait.until(
+            dex.Timer.by_duration(timedelta(seconds=1))
+        )
+
+    def execute(
+        self, context: dex.Context, input: str
+    ) -> dex.StepDecision:
+        return dex.graceful_complete(input)
+
+class CounterFlow(dex.Flow[str]):
+    run = Run()
+
+    def get_flow_type(self) -> str:
+        return "Counter"
+
+    def get_steps(self) -> dex.StepList[str]:
+        return dex.StepList.start_step(self.run)
+
+    def get_persistence_schema(self) -> dex.PersistenceSchema:
+        return dex.PersistenceSchema.of(counter, counters_by_region)
+
+    @dex.rpc(name="Increment")
+    def increment(
+        self, context: dex.Context, input: int
+    ) -> dex.RPCResult[int]:
+        return dex.RPCResult(input + 1)
+
+flow = CounterFlow()
+registry = dex.Registry((flow,))
+```
+
+Registry derives codecs from declared Python types and handler annotations.
+Built-in scalar types and dataclasses need no codec arguments. Register an
+explicit codec only for a custom encoding or a type Registry cannot derive.
+`PersistenceSchema.of(...)` accepts attributes and channels together and
+partitions them by definition type.
+
+`Worker` and `AsyncWorker` synchronize all registered Indexed Attributes with
+Dex Server before opening their listener. Existing indexes return immediately;
+failure or the default two-minute deadline aborts startup. An indexed
+`AttributeMap` must provide one fixed `index_key`.
+
+Initial attributes retain their value types without a public wrapper class:
+
+```python
+options = (
+    dex.StartFlowOptions()
+    .with_attribute(counter, 1)
+    .with_attribute(counters_by_region, "us-west", 1)
+)
+```
+
+Opt in when declaring an Attribute or AttributeMap, and select the Store in
+Flow configuration:
+
+```python
+email = dex.Attribute("customer-email", str, sync_to_attribute_store=True)
+config = dex.FlowConfig(attribute_store_name="profiles")
+```
+
+The Store is an asynchronous latest-state projection. Deletion writes SQL
+`NULL`, and projection failures do not roll back Flow Attributes. `None`
+preserves the current target; an explicit empty string disables future
+synchronization while retaining protocol presence.
+
+```
+pip install dex-python-sdk==0.1.0
+```
+
+See [samples](../examples/python) for use case examples.
+
+## Requirements
+
+- Python 3.11+
+- [Dex server](https://github.com/superdurable/dex#how-to-use)
+
+## Concepts
+
+Applications implement two generic interfaces from [`dex`](dex/):
+
+- `Flow[START_INPUT]` returns `StepList.start_step(...)`, followed by optional
+  `.other_steps(...)`, from one `get_steps()` method. The `StepList` generic
+  binds the Flow input to the starting Step input. Use `StepList.empty()` when
+  a Flow has no Steps.
+- `Step[INPUT]` implements `execute` and optionally `wait_for`. The default
+  Worker path requires synchronous handlers. With `AsyncWorker` and
+  `Registry(..., allow_async_handlers=True)`, handlers may be `async def` and
+  `await` an `AsyncClient`.
+
+`StepOptions.wait_for_method_timeout` and `execute_method_timeout` bound the
+two handler calls. Timer and channel conditions determine how long a Step waits.
+
+`Registry` validates every Flow, Step, RPC signature, durable name, lock, and
+codec before Client or Worker startup. `Client` methods use these typed objects
+instead of raw Flow, Step, or RPC strings.
+
+### Errors
+
+Client calls raise concrete `DexServiceError` subclasses. Existing-Flow reads
+(`get_attribute`, `describe_flow`, `wait_for_flow`, and `reset_flow`) raise
+`FlowNotFoundError` when the Flow does not exist. Mutations, RPCs, timer/Step
+waits, config updates, and continue-as-new triggers raise
+`FlowNotActiveError` when no running Flow can accept the operation.
+
+```python
+try:
+    client.publish(flow_id, orders.approved, order_id)
+except dex.FlowNotActiveError:
+    # The Flow is missing or already closed.
+    pass
+```
+
+Duplicate starts, worker failures, RPC lock contention, and long-poll timeouts
+raise `FlowAlreadyStartedError`, `WorkerInvocationError`,
+`RpcLockConflictError`, and `LongPollTimeoutError`. All service errors retain
+`code`, `sub_status`, `detail`, `operation`, `flow_id`, and the original gRPC
+exception through Python exception chaining. Worker failures also expose
+`worker_code`, `worker_error_type`, and `worker_error_detail`. Registration,
+serialization, and invalid handler returns use `FlowDefinitionError`,
+`ValueMappingError`, and `InvalidStepResultError`.
+
+### Sync vs asyncio
+
+- **Sync (default):** `Client` and `Worker` use blocking gRPC and a thread-pool
+  Worker. Blocking `Client` calls inside `Step.execute` are safe (one pool
+  thread is occupied; other RPCs still run).
+- **Asyncio:** `AsyncClient` and `AsyncWorker` use `grpc.aio`. Use
+  `Registry(..., allow_async_handlers=True)` when Steps/RPCs are coroutines.
+  Inside async `execute`, inject `AsyncClient` — do not call sync `Client` on
+  the Worker event loop. Sync `Worker` still rejects coroutine handlers at
+  registry construction unless `allow_async_handlers=True` (and even then the
+  sync Worker dispatcher rejects awaitable return values).
+
+Integration scenarios live under
+[`tests/integ`](tests/integ/README.md). They exercise the same workflows,
+client operations, and assertions as the Java suite against an isolated
+`dexcli dev` environment.
+
+## Implementation status
+
+The strongly typed contracts, registry, synchronous Client/Worker, optional
+`AsyncClient`/`AsyncWorker` (`grpc.aio`), and Rust-backed BlobCache are
+implemented. Python owns its gRPC transport; the native bridge is limited to
+the shared BlobCache. Design notes:
+[`docs/design/plan/python-sdk-async-apis.md`](../docs/design/plan/python-sdk-async-apis.md).
+
+## Running dex-server locally
+
+### Option 1: use docker compose
+See [dex README](https://github.com/superdurable/dex#using-docker-image--docker-compose)
+
+### Option 2: VSCode Dev Container
+
+Dev Container is an easy way to get dex-server running locally. Follow these steps to launch a dev container:
+- Install Docker, VSCode, and [VSCode Dev Container plugin](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers).
+- Open the project in VSCode.
+    ```bash
+    cd dex-python-sdk
+    code .
+    ```
+- Launch the Remote-Containers: Reopen in Container command from Command Palette (Ctrl + Shift + P). You can also click in the bottom left corner to access the remote container menu.
+- Once the dev container starts, dex-server will be listening on port 8801.
+
+## How To Contribute
+
+This project uses [uv](https://docs.astral.sh/uv/) for Python versions,
+dependencies, virtual environments, locking, building, and publishing.
+
+To install requirements:
+
+```bash
+uv sync --locked
+```
+
+Run the complete Python SDK integration suite with an isolated Dex development
+environment:
+
+```bash
+./run-integration-tests.sh
+```
+
+### Measure integration coverage
+
+Run the same integration suite with Python source coverage:
+
+```bash
+./run-integration-tests.sh --coverage
+```
+
+Only the integration scenarios contribute execution data, and only production
+Python modules under `dex` are measured. Generated protobuf modules under
+`dex/dexpb` are excluded. The
+terminal report lists uncovered line ranges. The browser report starts at
+`coverage/html/index.html`; `coverage/coverage.xml` and `coverage/lcov.info`
+are also generated.
+
+CI uploads LCOV to Codecov with GitHub OIDC under the
+`sdk-python-integration` flag and retains the full report as the
+`sdk-python-integration-coverage` Actions artifact.
+
+#### Update IDL
+
+Edit [`protos/dex.proto`](../protos/dex.proto). Rename catalog: [`docs/design/idl-renames.md`](../docs/design/idl-renames.md).
+
+#### Generate stubs from IDL
+
+```bash
+make -C ../protos proto-python
+```
+
+Checked-in Python stubs land in `dex/dexpb/`.
+#### Linting
+
+Validate that every `dex.__all__` class, function, constant, public method,
+argument, return value, dataclass field, enum value, and public instance
+attribute has a Google-style docstring:
+
+```bash
+uv run --frozen python scripts/check_public_docs.py
+```
+
+The checker resolves definitions from the public package export table, so
+private helpers and generated protobuf modules are excluded. Use `help(dex.Client)`
+or IDE hover information to read the same documentation. To run all other
+linting for this project:
+
+```bash
+uv run --frozen pre-commit run --show-diff-on-failure --color=always --all-files
+```
+
+## Code of Conduct
+This project is governed by the [Contributor Covenant v 1.4.1](CODE_OF_CONDUCT.md). (Review the Code of Conduct and remove this sentence before publishing your project.)
+
+## Publishing to PyPI
+
+1. Optionally run **Publish Python SDK to PyPI** via workflow_dispatch with a version and
+   `publish=false` to validate all distributions without uploading.
+2. Create a GitHub Release with tag `sdk-python/vX.Y.Z` (for example `sdk-python/v0.1.0`).
+   CI stamps that version into `pyproject.toml` for the build (same idea as the TypeScript
+   SDK release), then builds and smoke-tests Linux x86_64/ARM64, macOS x86_64/ARM64, and
+   Windows x86_64 wheels, verifies the source distribution, and publishes with `PYPI_TOKEN`.
+3. After publishing, bump the committed `pyproject.toml` / docs install line when you want
+   the repo tip to reflect the released version.
+
+A manual run publishes only from `main`, and only when `publish` is explicitly selected.
+The dispatch `version` input is stamped the same way as a release tag.
+
+See [CONTRIBUTING.md](../CONTRIBUTING.md#releases-monorepo-tags) for monorepo tag conventions.
+
+## License
+
+[Super Durable Source License 1.0](LICENSE), with legacy portions under their
+original terms as described in [LEGACY_NOTICES.md](LEGACY_NOTICES.md).

{dex_python_sdk-0.0.2 → dex_python_sdk-0.1.2}/dex/__init__.py

@@ -17,6 +17,8 @@ from dex.attribute import (
 )
 from dex.blob_cache import BlobCache, BlobCacheConfig, open_blob_cache
 from dex.channel import Channel, ChannelMap
+from dex.async_client import AsyncClient
+from dex.async_worker import AsyncWorker
 from dex.client import Client
 from dex.client_options import ClientOptions
 from dex.codec import (
@@ -35,7 +37,13 @@ from dex.condition import ConditionCombination
 from dex.context import Context
 from dex.flow import Flow, PersistenceSchema, Registry, RPCResult, rpc
 from dex.flow_config import ActiveStepSearchMode, FlowConfig
-from dex.flow_info import FlowInfo, FlowStatus, HealthInfo, SearchFlowEntry
+from dex.flow_info import (
+    FlowInfo,
+    FlowStatus,
+    HealthInfo,
+    SearchFlowEntry,
+    SearchFlowsPage,
+)
 from dex.flow_options import (
     IdReusePolicy,
     ResetFlowOptions,
@@ -45,11 +53,19 @@ from dex.flow_options import (
     StopType,
 )
 from dex.runtime_errors import (
-    DexException,
+    DexServiceError,
     ErrorSubStatus,
+    FlowAlreadyStartedError,
+    FlowDefinitionError,
     FlowErrorType,
+    FlowNotActiveError,
+    FlowNotFoundError,
     FlowUncompletedError,
+    InvalidStepResultError,
     LongPollTimeoutError,
+    RpcLockConflictError,
+    ValueMappingError,
+    WorkerInvocationError,
 )
 from dex.step import (
     RetryPolicy,
@@ -85,6 +101,8 @@ __all__ = [
     "AttributeIndex",
     "AttributeLock",
     "AttributeMap",
+    "AsyncClient",
+    "AsyncWorker",
     "BlobCache",
     "BlobCacheConfig",
     "Channel",
@@ -95,26 +113,33 @@ __all__ = [
     "CodecRegistry",
     "ConditionCombination",
     "Context",
-    "DexException",
+    "DexServiceError",
     "ErrorSubStatus",
     "Flow",
+    "FlowAlreadyStartedError",
     "FlowConfig",
+    "FlowDefinitionError",
     "FlowErrorType",
     "FlowInfo",
+    "FlowNotActiveError",
+    "FlowNotFoundError",
     "FlowStatus",
     "FlowUncompletedError",
     "HealthInfo",
     "IdReusePolicy",
+    "InvalidStepResultError",
     "IndexType",
     "JsonCodec",
     "LongPollTimeoutError",
     "PersistenceSchema",
     "RPCResult",
+    "RpcLockConflictError",
     "Registry",
     "ResetFlowOptions",
     "ResetType",
     "RetryPolicy",
     "SearchFlowEntry",
+    "SearchFlowsPage",
     "StartFlowOptions",
     "StepExecutionId",
     "StepDecision",
@@ -128,10 +153,12 @@ __all__ = [
     "Timer",
     "TimerId",
     "Value",
+    "ValueMappingError",
     "Wait",
     "WaitForFailurePolicy",
     "WireKind",
     "Worker",
+    "WorkerInvocationError",
     "WorkerOptions",
     "WorkerTarget",
     "dead_end",