dex-python-sdk 1.23.0__tar.gz → 1.25.0__tar.gz

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dex-python-sdk
-Version: 1.23.0
+Version: 1.25.0
 Requires-Dist: grpcio>=1.83.0
 Requires-Dist: grpcio-status>=1.83.0
 Requires-Dist: protobuf>=7.35.1
@@ -95,14 +95,17 @@ retain up to four idle credential threads. Sync token lookup must return
 promptly. By default, no authorization metadata is sent. Dex uses plaintext
 gRPC, so protect the network path that carries the token.
 
-## Pull mode
+## Workers
 
-Set `WorkerOptions.pull` to run a `Worker` or `AsyncWorker` with outbound task
-streams. The Worker connects to the Dex server through `server_address` and
-does not open a listener. Advertise `worker.worker_target` through
-`ClientOptions.worker_target`. A single Flow can override the Client default
-with `StartFlowOptions(config_override=FlowConfig(worker_target=...))`; a
-SubFlow can use `SubFlowOptions` with the same `FlowConfig` override.
+Workers receive tasks through outbound pull streams. `Worker` and `AsyncWorker`
+need only an outbound connection to the Dex Server at `server_address`. Configure
+capacity and shutdown with `WorkerOptions.pull`; its default is
+`PullWorkerOptions()`. Clients and Flows use pull routing automatically.
+
+StartFlow and SubFlow always select pull Workers. Updating Flow configuration
+preserves its existing Worker target; an empty `FlowConfig()` changes nothing.
+Before upgrading an application with active push Flows, use an SDK version that
+supports Worker targets to migrate those Flows to pull routing.
 
 ```python
 import threading
@@ -118,10 +121,11 @@ worker = Worker(
 )
 worker_thread = threading.Thread(target=worker.start)
 worker_thread.start()
+worker.wait_pull_registered(timeout=30)
 client = Client(
     registry,
     cache,
-    ClientOptions(server_address="dex.example:8801", worker_target=worker.worker_target),
+    ClientOptions(server_address="dex.example:8801"),
 )
 try:
     client.start_flow(flow, flow_id, input_value)
@@ -160,10 +164,7 @@ The generated `app_worker_id` uses the first nonempty `DEX_WORKER_INSTANCE`,
 `POD_NAME`, `HOSTNAME`, or system hostname, plus eight random base32 characters.
 An override must uniquely identify one Worker process and change after restart.
 It must contain 1-63 ASCII letters, digits, dots, underscores, or hyphens and
-must not equal a registered Flow type. Pull mode cannot configure a bind address
-or an advertised address or headless target. Use `WorkerTarget(pull=True)` for
-Client defaults or Flow overrides when the Worker target is not directly in
-scope.
+must not equal a registered Flow type.
 
 Pull streams reconnect after failures. A server-directed reconnect waits for
 an active task to finish, then waits up to `stop_drain_timeout` for the server
@@ -186,7 +187,7 @@ Worker ID queue to register at least once. Timeout raises `TimeoutError`;
 async cancellation cancels only that wait. Startup failures reach waiters.
 A permanent rejection before readiness raises `PullRegistrationError`, whose
 `queue` and `error` identify the rejected queue and original transport error.
-Listening mode and stop before readiness raise `RuntimeError`.
+Stopping before readiness raises `RuntimeError`.
 
 Use `worker.pull_registration_state()` for subsequent readiness probes. Its
 immutable `queues` expose `queue`, `has_registered_stream`, and
@@ -240,7 +241,6 @@ to distinguish reserve pressure from full-capacity rejections. The count exclude
 full-capacity rejections and unknown names. It counts decline events, including
 repeated declines of the same Step dispatch while Dex retries it. Read its rate
 to assess reserve pressure. It never resets and remains available after shutdown.
-Listening Workers return zero.
 
 ## Flow state I/O
 
@@ -398,7 +398,7 @@ explicit codec only for a custom encoding or a type Registry cannot derive.
 partitions them by definition type.
 
 `Worker` and `AsyncWorker` synchronize all registered Indexed Attributes with
-Dex Server before opening their listener. Existing indexes return immediately;
+Dex Server before opening outbound task streams. Existing indexes return immediately;
 failure or the default two-minute deadline aborts startup. An indexed
 `AttributeMap` must provide one fixed `index_key`.
 
@@ -794,8 +794,8 @@ environment:
 ./run-integration-tests.sh
 ```
 
-Set `DEX_INTEG_WORKER_MODE=pull` to run the suite with pull Workers instead of
-listening Workers. The default is `push`.
+The suite always uses pull Workers. Set `DEX_INTEG_ENGINE=zd` to test against
+server-zd, or leave it unset to use the Temporal-backed server.
 
 ### Measure integration coverage
 
@@ -868,9 +868,9 @@ See [CONTRIBUTING.md](../CONTRIBUTING.md#releases-monorepo-tags) for monorepo ta
 ## Server protocol compatibility
 
 Both `Worker` and `AsyncWorker` call `GetServerInfo`, negotiate the highest
-common protocol, synchronize Attribute indexes, and only then bind
-WorkerService. The initial Python SDK interval is `[1,1]`. Missing information,
-invalid or disjoint intervals, and RPC failures stop startup before binding.
+common protocol, synchronize Attribute indexes, and only then open outbound
+task streams. The initial Python SDK interval is `[1,1]`. Missing information,
+invalid or disjoint intervals, and RPC failures stop startup before polling.
 The current Python SDK interval is `[1,3]`. Protocol 3 adds hard-delete
 Attributes. Workers record the negotiated version at startup and reject each
 handler result that contains a hard-delete Attribute write when it is below 3.

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/README.md

@@ -79,14 +79,17 @@ retain up to four idle credential threads. Sync token lookup must return
 promptly. By default, no authorization metadata is sent. Dex uses plaintext
 gRPC, so protect the network path that carries the token.
 
-## Pull mode
+## Workers
 
-Set `WorkerOptions.pull` to run a `Worker` or `AsyncWorker` with outbound task
-streams. The Worker connects to the Dex server through `server_address` and
-does not open a listener. Advertise `worker.worker_target` through
-`ClientOptions.worker_target`. A single Flow can override the Client default
-with `StartFlowOptions(config_override=FlowConfig(worker_target=...))`; a
-SubFlow can use `SubFlowOptions` with the same `FlowConfig` override.
+Workers receive tasks through outbound pull streams. `Worker` and `AsyncWorker`
+need only an outbound connection to the Dex Server at `server_address`. Configure
+capacity and shutdown with `WorkerOptions.pull`; its default is
+`PullWorkerOptions()`. Clients and Flows use pull routing automatically.
+
+StartFlow and SubFlow always select pull Workers. Updating Flow configuration
+preserves its existing Worker target; an empty `FlowConfig()` changes nothing.
+Before upgrading an application with active push Flows, use an SDK version that
+supports Worker targets to migrate those Flows to pull routing.
 
 ```python
 import threading
@@ -102,10 +105,11 @@ worker = Worker(
 )
 worker_thread = threading.Thread(target=worker.start)
 worker_thread.start()
+worker.wait_pull_registered(timeout=30)
 client = Client(
     registry,
     cache,
-    ClientOptions(server_address="dex.example:8801", worker_target=worker.worker_target),
+    ClientOptions(server_address="dex.example:8801"),
 )
 try:
     client.start_flow(flow, flow_id, input_value)
@@ -144,10 +148,7 @@ The generated `app_worker_id` uses the first nonempty `DEX_WORKER_INSTANCE`,
 `POD_NAME`, `HOSTNAME`, or system hostname, plus eight random base32 characters.
 An override must uniquely identify one Worker process and change after restart.
 It must contain 1-63 ASCII letters, digits, dots, underscores, or hyphens and
-must not equal a registered Flow type. Pull mode cannot configure a bind address
-or an advertised address or headless target. Use `WorkerTarget(pull=True)` for
-Client defaults or Flow overrides when the Worker target is not directly in
-scope.
+must not equal a registered Flow type.
 
 Pull streams reconnect after failures. A server-directed reconnect waits for
 an active task to finish, then waits up to `stop_drain_timeout` for the server
@@ -170,7 +171,7 @@ Worker ID queue to register at least once. Timeout raises `TimeoutError`;
 async cancellation cancels only that wait. Startup failures reach waiters.
 A permanent rejection before readiness raises `PullRegistrationError`, whose
 `queue` and `error` identify the rejected queue and original transport error.
-Listening mode and stop before readiness raise `RuntimeError`.
+Stopping before readiness raises `RuntimeError`.
 
 Use `worker.pull_registration_state()` for subsequent readiness probes. Its
 immutable `queues` expose `queue`, `has_registered_stream`, and
@@ -224,7 +225,6 @@ to distinguish reserve pressure from full-capacity rejections. The count exclude
 full-capacity rejections and unknown names. It counts decline events, including
 repeated declines of the same Step dispatch while Dex retries it. Read its rate
 to assess reserve pressure. It never resets and remains available after shutdown.
-Listening Workers return zero.
 
 ## Flow state I/O
 
@@ -382,7 +382,7 @@ explicit codec only for a custom encoding or a type Registry cannot derive.
 partitions them by definition type.
 
 `Worker` and `AsyncWorker` synchronize all registered Indexed Attributes with
-Dex Server before opening their listener. Existing indexes return immediately;
+Dex Server before opening outbound task streams. Existing indexes return immediately;
 failure or the default two-minute deadline aborts startup. An indexed
 `AttributeMap` must provide one fixed `index_key`.
 
@@ -778,8 +778,8 @@ environment:
 ./run-integration-tests.sh
 ```
 
-Set `DEX_INTEG_WORKER_MODE=pull` to run the suite with pull Workers instead of
-listening Workers. The default is `push`.
+The suite always uses pull Workers. Set `DEX_INTEG_ENGINE=zd` to test against
+server-zd, or leave it unset to use the Temporal-backed server.
 
 ### Measure integration coverage
 
@@ -852,9 +852,9 @@ See [CONTRIBUTING.md](../CONTRIBUTING.md#releases-monorepo-tags) for monorepo ta
 ## Server protocol compatibility
 
 Both `Worker` and `AsyncWorker` call `GetServerInfo`, negotiate the highest
-common protocol, synchronize Attribute indexes, and only then bind
-WorkerService. The initial Python SDK interval is `[1,1]`. Missing information,
-invalid or disjoint intervals, and RPC failures stop startup before binding.
+common protocol, synchronize Attribute indexes, and only then open outbound
+task streams. The initial Python SDK interval is `[1,1]`. Missing information,
+invalid or disjoint intervals, and RPC failures stop startup before polling.
 The current Python SDK interval is `[1,3]`. Protocol 3 adds hard-delete
 Attributes. Workers record the negotiated version at startup and reject each
 handler result that contains a hard-delete Attribute write when it is below 3.

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/dex/__init__.py

@@ -124,7 +124,7 @@ from dex.timer import Timer
 from dex.wait import Wait
 from dex.wait_options import WaitForAttributeOptions, WaitForStepCompletionOptions
 from dex.worker import Worker
-from dex.worker_options import PullWorkerOptions, WorkerOptions, WorkerTarget
+from dex.worker_options import PullWorkerOptions, WorkerOptions
 
 __all__ = [
     "BOOL",
@@ -226,7 +226,6 @@ __all__ = [
     "Worker",
     "WorkerInvocationError",
     "WorkerOptions",
-    "WorkerTarget",
     "PullWorkerOptions",
     "PullRegistrationError",
     "PullRegistrationState",

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/dex/_grpc_errors.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import traceback
 from dataclasses import dataclass
-from typing import Any, Literal, cast
+from typing import Literal, cast
 
 import grpc
 from google.protobuf import any_pb2
@@ -165,23 +165,6 @@ def _worker_code(details: pb.ServiceErrorResponse | None) -> grpc.StatusCode | N
     )
 
 
-def abort_worker_error(
-    context: grpc.ServicerContext,
-    error: BaseException,
-) -> None:
-    context.abort_with_status(rpc_status.to_status(_worker_error_status(error)))
-
-
-async def async_abort_worker_error(
-    context: grpc.aio.ServicerContext[Any, Any],
-    error: BaseException,
-) -> None:
-    # types-grpcio on 3.11 omits aio abort_with_status; runtime provides it.
-    await cast(Any, context).abort_with_status(
-        rpc_status.to_status(_worker_error_status(error))
-    )
-
-
 def _worker_error_status(error: BaseException) -> status_pb2.Status:
     retry_after_error: RetryAfterError | None = None
     reported = error

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/dex/_pull_worker.py

@@ -805,6 +805,21 @@ class PullStream:
         async with self._send_lock:
             if request.HasField("task_frame"):
                 frame = request.task_frame
+                is_progress_frame = (
+                    frame.HasField("wait_for")
+                    and frame.wait_for.WhichOneof("output")
+                    in ("heartbeat", "stream_write")
+                    or frame.HasField("execute")
+                    and frame.execute.WhichOneof("output")
+                    in ("heartbeat", "stream_write")
+                )
+                if (
+                    frame.task_id != self.task_id
+                    or self._is_final_frame_sent
+                    or not self._active.is_set()
+                    and is_progress_frame
+                ):
+                    return
                 if (
                     frame.HasField("rpc")
                     or frame.HasField("worker_error")

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/dex/_worker_dispatcher.py

@@ -711,6 +711,9 @@ class WorkerDispatcher:
             mapped.flow_config_override.CopyFrom(
                 self._map_sub_flow_config(options.config_override)
             )
+        mapped.flow_config_override.worker_target.CopyFrom(
+            pb.WorkerTarget(is_pull_mode=True)
+        )
         return mapped
 
     def _result_attribute_writes(
@@ -761,14 +764,7 @@ class WorkerDispatcher:
                 StepDurability.SYNC: pb.STEP_DURABILITY_SYNC,
                 StepDurability.ASYNC: pb.STEP_DURABILITY_ASYNC,
             }[config.step_durability]
-        if config.worker_target is not None:
-            mapped.worker_target.CopyFrom(
-                pb.WorkerTarget(
-                    address=config.worker_target.address,
-                    is_headless_address=config.worker_target.headless,
-                    is_pull_mode=config.worker_target.pull,
-                )
-            )
+        mapped.worker_target.CopyFrom(pb.WorkerTarget(is_pull_mode=True))
         if config.attribute_store_names is not None:
             mapped.attribute_store_names.CopyFrom(
                 pb.AttributeStoreNames(names=config.attribute_store_names)

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/dex/async_client.py

@@ -107,7 +107,7 @@ class AsyncClient:
         Args:
             registry: The Flow Registry used for validation and codecs.
             blob_cache: An open cache used for asynchronous hydration.
-            options: Service address, default Worker target, and bearer credential;
+            options: Service address and bearer credential;
                 ``None`` uses defaults and sends no authorization metadata.
         """
         self.registry = registry
@@ -1038,7 +1038,11 @@ class AsyncClient:
                 raise
 
     async def update_flow_config(self, flow_id: str, config: FlowConfig) -> None:
-        """Replace mutable configuration for an active Flow.
+        """Update specified mutable configuration fields for an active Flow.
+
+        The update affects later decisions and does not recall work already
+        dispatched. Unspecified fields and the existing Worker target remain
+        unchanged. An empty ``FlowConfig()`` leaves all configuration unchanged.
 
         Args:
             flow_id: The non-empty active Flow ID.
@@ -1193,13 +1197,12 @@ class AsyncClient:
             _apply_attribute_store_sync(write, definition)
             _apply_hard_delete_on_null(write, definition)
             mapped.attributes.append(write)
-        if (
-            options.config_override is not None
-            or self.options.worker_target is not None
-        ):
-            mapped.flow_config_override.CopyFrom(
-                self._map_flow_config(options.config_override)
-            )
+        mapped.flow_config_override.CopyFrom(
+            self._map_flow_config(options.config_override)
+        )
+        mapped.flow_config_override.worker_target.CopyFrom(
+            pb.WorkerTarget(is_pull_mode=True)
+        )
         return mapped
 
     def _map_flow_config(self, config: FlowConfig | None) -> pb.FlowConfig:
@@ -1236,19 +1239,6 @@ class AsyncClient:
                 mapped.attribute_store_names.CopyFrom(
                     pb.AttributeStoreNames(names=config.attribute_store_names)
                 )
-        target = (
-            config.worker_target
-            if config is not None and config.worker_target is not None
-            else self.options.worker_target
-        )
-        if target is not None:
-            mapped.worker_target.CopyFrom(
-                pb.WorkerTarget(
-                    address=target.address,
-                    is_headless_address=target.headless,
-                    is_pull_mode=target.pull,
-                )
-            )
         return mapped
 
     @staticmethod

{dex_python_sdk-1.23.0 → dex_python_sdk-1.25.0}/dex/async_worker.py

@@ -14,10 +14,9 @@ from types import TracebackType
 import grpc
 from google.protobuf import empty_pb2
 
-from dex._credential_transport import AsyncCredentialRunner, async_channel
 from dex._async_value_hydrator import AsyncValueHydrator
 from dex._async_worker_dispatcher import AsyncWorkerDispatcher
-from dex._async_worker_service import AsyncWorkerService
+from dex._credential_transport import AsyncCredentialRunner, async_channel
 from dex._pull_worker import PullWorkerRuntime, resolve_app_worker_id
 from dex._server_protocol import (
     NegotiatedServerProtocol,
@@ -31,15 +30,15 @@ from dex.dexpb import dex_pb2 as pb
 from dex.dexpb import dex_pb2_grpc
 from dex.flow import Registry
 from dex.pull_registration import PullRegistrationState
-from dex.worker_options import WorkerOptions, WorkerTarget
+from dex.worker_options import WorkerOptions
 
 
 class AsyncWorker:
-    """Host asynchronous Step and RPC handlers through a listener or pull streams.
+    """Host asynchronous Step and RPC handlers through outbound pull streams.
 
     A Worker is one-shot. Await ``start`` in a background task because it waits for
-    termination, and await ``stop`` or ``close`` during shutdown. Set
-    ``WorkerOptions.pull`` to poll Dex without a listener. Application handlers
+    termination, and await ``stop`` or ``close`` during shutdown. Workers need
+    only an outbound connection to the Dex Server. Application handlers
     may overlap on the event loop and must avoid blocking operations.
 
     Attributes:
@@ -60,7 +59,7 @@ class AsyncWorker:
         blob_cache: BlobCache,
         options: WorkerOptions | None = None,
     ) -> None:
-        """Construct an AsyncWorker without starting its listener or pull streams.
+        """Construct an AsyncWorker without starting its outbound pull streams.
 
         Args:
             registry: A Registry created with ``allow_async_handlers=True``.
@@ -69,16 +68,12 @@ class AsyncWorker:
                 ``None`` uses defaults and sends no authorization metadata.
 
         Raises:
-            ValueError: If a target, bind address, or pull Worker ID is invalid.
+            ValueError: If the pull Worker ID is invalid.
         """
         self.registry = registry
         self.blob_cache = blob_cache
         self.options = options or WorkerOptions()
-        app_worker_id = (
-            resolve_app_worker_id(registry, self.options.pull)
-            if self.options.pull is not None
-            else None
-        )
+        app_worker_id = resolve_app_worker_id(registry, self.options.pull)
         self._state = "created"
         self._credential_runner = (
             AsyncCredentialRunner(self.options.credential)
@@ -100,49 +95,22 @@ class AsyncWorker:
             AsyncValueHydrator(self._flow_service, blob_cache),
             self._server_protocol,
         )
-        self._server = None
         self._has_start_called = False
-        self._pull = None
-        if self.options.pull is not None:
-            self._pull = PullWorkerRuntime(
-                registry,
-                dispatcher,
-                self.options.pull,
-                self.options.server_address,
-                None,
-                app_worker_id,
-                self._credential_runner,
-            )
-        else:
-            self._server = grpc.aio.server()
-            dex_pb2_grpc.add_WorkerServiceServicer_to_server(  # type: ignore[no-untyped-call]
-                AsyncWorkerService(dispatcher),
-                self._server,
-            )
-        self._bound_port = 0
-        self._worker_target = (
-            WorkerTarget(pull=True)
-            if self._pull is not None
-            else self.options.worker_target
-            or WorkerTarget(self._target_address(self.options.bind_address, 0))
+        self._pull = PullWorkerRuntime(
+            registry,
+            dispatcher,
+            self.options.pull,
+            self.options.server_address,
+            None,
+            app_worker_id,
+            self._credential_runner,
         )
         self._stopped = asyncio.Event()
 
-    @property
-    def worker_target(self) -> WorkerTarget:
-        """Return the effective Worker target advertised to Dex.
-
-        Pull mode returns ``WorkerTarget(pull=True)`` without binding a port.
-
-        Returns:
-            The WorkerTarget, including the actual port after binding.
-        """
-        return self._worker_target
-
     async def __aenter__(self) -> AsyncWorker:
         """Return this Worker for asynchronous context-manager use.
 
-        Entering does not start the listener.
+        Entering does not start outbound task streams.
 
         Returns:
             This AsyncWorker instance.
@@ -167,14 +135,15 @@ class AsyncWorker:
     async def start(self) -> None:
         """Negotiate protocol, synchronize Attribute indexes, and serve.
 
-        ``start`` may be awaited exactly once. It contacts FlowService before binding
-        and completes only after ``stop`` terminates the listener or pull streams.
+        ``start`` may be awaited exactly once. It contacts FlowService before
+        opening outbound task streams and completes only after ``stop``
+        terminates those streams.
         Permanent pull stream rejections raise PullRegistrationError when
         stop_on_permanent_stream_rejection is enabled; otherwise streams retry.
 
         Raises:
             PullRegistrationError: A permanent stream rejection stops this Worker.
-            RuntimeError: If lifecycle state, index synchronization, or binding fails.
+            RuntimeError: If lifecycle state is invalid or index synchronization fails.
         """
         if self._has_start_called:
             raise RuntimeError("Worker can only start once")
@@ -186,10 +155,9 @@ class AsyncWorker:
             start_error = failure
             raise
         finally:
-            if self._pull is not None:
-                self._pull.registration.finish_start(start_error)
-                if self._state == "running":
-                    await self.stop()
+            self._pull.registration.finish_start(start_error)
+            if self._state == "running":
+                await self.stop()
 
     async def wait_pull_registered(self, timeout: float | None = None) -> None:
         """Wait until every pull queue has registered at least once.
@@ -208,7 +176,7 @@ class AsyncWorker:
             PullRegistrationError: A queue is permanently rejected before readiness.
             TimeoutError: The timeout expires.
             asyncio.CancelledError: The calling task is canceled; the Worker keeps running.
-            RuntimeError: This is a listening Worker, or it stops before readiness.
+            RuntimeError: The Worker stops before readiness.
             BaseException: The original startup failure, if start fails.
 
         Examples:
@@ -217,8 +185,6 @@ class AsyncWorker:
             >>> await worker.wait_pull_registered(timeout=30)
             >>> is_ready = worker.pull_registration_state().is_ready
         """
-        if self._pull is None:
-            raise RuntimeError("wait_pull_registered requires a pull Worker")
         await self._pull.registration.wait_async(timeout)
 
     @property
@@ -229,16 +195,16 @@ class AsyncWorker:
         repeatedly while retrying it, so read the counter as a rate.
         Full-capacity rejections and unknown names are excluded. The count never
         resets during this Worker's lifetime and stays available after stop.
-        Reading it alongside handlers is safe. Listening Workers return zero.
+        Reading it alongside handlers is safe.
         Export this value to a monitoring counter to identify reserve pressure.
 
         Returns:
-            The cumulative reserve-decline count, or zero for a listening Worker.
+            The cumulative reserve-decline count.
 
         Examples:
             >>> declines = worker.pull_reserved_rpc_declines
         """
-        return 0 if self._pull is None else self._pull.reserved_rpc_declines
+        return self._pull.reserved_rpc_declines
 
     def pull_registration_state(self) -> PullRegistrationState:
         """Return an immutable snapshot of pull queue registrations.
@@ -250,13 +216,9 @@ class AsyncWorker:
         for an example.
 
         Returns:
-            Current per-queue state, or an empty nonready state in listening mode.
+            Current per-queue state.
         """
-        return (
-            PullRegistrationState()
-            if self._pull is None
-            else self._pull.registration.snapshot()
-        )
+        return self._pull.registration.snapshot()
 
     async def _start(self) -> None:
         if self._state != "created":
@@ -302,27 +264,8 @@ class AsyncWorker:
             await self._close_failed_start_channel()
             self._stopped.set()
             raise RuntimeError("cannot synchronize Attribute indexes") from failure
-        if self._pull is None:
-            assert self._server is not None
-            self._bound_port = self._server.add_insecure_port(self.options.bind_address)
-            if self._bound_port == 0:
-                self._state = "stopped"
-                await self._close_failed_start_channel()
-                self._stopped.set()
-                raise RuntimeError(
-                    f"cannot bind Python AsyncWorker to {self.options.bind_address}"
-                )
-            if self.options.worker_target is None:
-                self._worker_target = WorkerTarget(
-                    self._target_address(self.options.bind_address, self._bound_port)
-                )
         self._state = "running"
-        if self._pull is not None:
-            await self._pull.run()
-        else:
-            assert self._server is not None
-            await self._server.start()
-            await self._server.wait_for_termination()
+        await self._pull.run()
         self._stopped.set()
 
     async def stop(self) -> None:
@@ -334,16 +277,11 @@ class AsyncWorker:
         Half-closed pull streams wait for server EOF until the remaining drain
         deadline before the channel closes.
         """
-        if self._pull is not None:
-            self._pull.registration.record_stopping()
+        self._pull.registration.record_stopping()
         if self._state in ("stopped", "closed"):
             return
         self._state = "stopping"
-        if self._pull is not None:
-            await self._pull.stop()
-        else:
-            assert self._server is not None
-            await self._server.stop(grace=5)
+        await self._pull.stop()
         try:
             await self._flow_channel.close(None)
         finally:
@@ -372,14 +310,3 @@ class AsyncWorker:
         finally:
             if self._credential_runner is not None:
                 self._credential_runner.close()
-
-    @staticmethod
-    def _target_address(bind_address: str, bound_port: int) -> str:
-        host, separator, port = bind_address.rpartition(":")
-        if not separator or not port:
-            raise ValueError("Worker bind address requires a port")
-        if bound_port == 0:
-            bound_port = int(port)
-        if host in ("", "0.0.0.0", "::", "[::]"):
-            host = "localhost"
-        return f"{host}:{bound_port}"