durable-workflow 2.10.0__tar.gz → 2.10.1__tar.gz

{durable_workflow-2.10.0/src/durable_workflow.egg-info → durable_workflow-2.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.10.0
+Version: 2.10.1
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "durable-workflow"
-version = "2.10.0"
+version = "2.10.1"
 description = "Python client and worker SDK for Durable Workflow Cloud and self-hosted Server"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -76,8 +76,8 @@ durable-workflow-replay-conformance = "durable_workflow.replay_conformance:main"
 durable-workflow-workflow-updates-conformance = "durable_workflow.workflow_updates_conformance:main"
 
 [tool.durable-workflow]
-product-train = "2.10.0"
-registry-version = "2.10.0"
+product-train = "2.10.1"
+registry-version = "2.10.1"
 supported-server-versions = "2.8.0"
 worker-protocol-version = "1.20"
 control-plane-version = "2"

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/src/durable_workflow/_metric_routes.py

@@ -12,6 +12,7 @@ _ROUTES = (
       for suffix in ("", "/pass")),
     "/workers", "/workers/{worker_id}",
     "/worker/register", "/worker/heartbeat", "/worker/registrations/{worker_id}",
+    "/worker/registrations/{worker_id}/deregister",
     "/worker/sessions", "/worker/sessions/{session_id}", "/worker/sessions/{session_id}/heartbeat",
     *(f"/worker/{kind}-tasks/poll" for kind in ("workflow", "activity", "query", "update-validation")),
     *(f"/worker/{kind}-tasks/{{task_id}}/{action}" for kind, actions in (

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/src/durable_workflow/client.py

@@ -1853,6 +1853,7 @@ class Client:
         json: Any = None,
         timeout: float | None = None,
         context: str = "",
+        retry: bool = True,
     ) -> Any:
         if worker and discovery:
             raise ValueError("a request cannot be both worker-plane and cluster discovery")
@@ -1920,7 +1921,7 @@ class Client:
 
         try:
             try:
-                resp = await self.retry_policy.execute(_do_request)
+                resp = await self.retry_policy.execute(_do_request) if retry else await _do_request()
             except httpx.HTTPStatusError as exc:
                 status_code = str(exc.response.status_code)
                 outcome = "http_error"
@@ -5245,39 +5246,69 @@ class Client:
             json={"worker_id": worker_id, "reason": reason},
         ))
 
-    async def deregister_worker_registration(self, worker_id: str) -> dict[str, Any]:
+    async def deregister_worker_registration(
+        self, worker_id: str, *, registration_token: str | None = None, timeout: float | None = None,
+        expected_namespace: str | None = None,
+    ) -> dict[str, Any]:
         """Remove this runtime's successful worker-plane registration.
 
         Called by :class:`~durable_workflow.Worker` after its pollers and
         in-flight tasks have drained. This is distinct from the operator-only
         :meth:`deregister_worker` control-plane management operation. Returns
         the worker deregistration envelope, including recovered workflow-task
-        count.
+        count. With a registration token, use the runtime's generation-fenced
+        receipt endpoint. Each call makes one attempt: Worker owns safe retries
+        and the remaining shutdown budget. An unfenced DELETE cannot safely be
+        repeated after an uncertain response because the worker ID may be reused.
+        ``expected_namespace`` is a local registration-scope precondition, not
+        a namespace override.
         """
+        if expected_namespace is not None and self.namespace != expected_namespace:
+            raise RuntimeError("worker registration namespace changed; registration removal is unconfirmed")
+        if registration_token is not None and (
+            not isinstance(registration_token, str) or re.fullmatch(r"[a-f0-9]{32}", registration_token) is None
+        ):
+            raise ValueError("registration_token must contain exactly 32 lowercase hexadecimal characters")
+        fenced = registration_token is not None
         try:
             data = await self._request(
-                "DELETE",
-                f"/worker/registrations/{quote(worker_id, safe='')}",
+                "POST" if fenced else "DELETE",
+                f"/worker/registrations/{quote(worker_id, safe='')}" + ("/deregister" if fenced else ""),
                 worker=True,
                 context=worker_id,
+                json={"registration_token": registration_token} if fenced else None,
+                timeout=timeout,
+                retry=False,
             )
         except ServerError as error:
-            if error.status == 404 and error.reason() == "worker_not_found":
+            if not fenced and error.status == 404 and error.reason() == "worker_not_found":
                 return {
                     "worker_id": worker_id,
                     "outcome": "already_deregistered",
                     "recovered_workflow_task_count": 0,
                 }
             raise
-        if not isinstance(data, dict):
+        if not self._valid_worker_deregistration_response(data, worker_id, registration_token):
             raise ServerError(
                 200,
                 {
                     "reason": "invalid_worker_deregistration_response",
-                    "message": f"expected JSON object, got {type(data).__name__}",
+                    "message": "expected a deregistration receipt for this worker registration",
                 },
             )
-        return data
+        return cast(dict[str, Any], data)
+
+    @staticmethod
+    def _valid_worker_deregistration_response(data: Any, worker_id: str, token: str | None) -> bool:
+        if not isinstance(data, dict):
+            return False
+        count = data.get("recovered_workflow_task_count")
+        return (
+            data.get("worker_id") == worker_id
+            and data.get("outcome") == "deregistered"
+            and type(count) is int and count >= 0
+            and (token is None or data.get("registration_token") == token)
+        )
 
     async def heartbeat_worker(
         self,

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/src/durable_workflow/errors.py

@@ -219,6 +219,21 @@ class ServerError(DurableWorkflowError):
             return self.body.get("reason")
         return None
 
+    def worker_deregistration_retry_delay(self, worker_id: str, registration_token: str) -> int | None:
+        """Return a delay only for an identity-preserving fenced transient."""
+        body = self.body
+        if (
+            self.status != 503 or not isinstance(body, dict)
+            or body.get("reason") not in ("backend_lock_pressure", "backend_unavailable")
+            or body.get("operation") != "deregister_worker" or body.get("outcome") != "unknown"
+            or body.get("worker_id") != worker_id or body.get("registration_token") != registration_token
+            or body.get("retryable") is not True
+            or type(body.get("retry_after_seconds")) is not int
+            or not 0 < body["retry_after_seconds"] <= 60
+        ):
+            return None
+        return int(body["retry_after_seconds"])
+
     def poll_capacity_backpressure_delay(self, task_kind: str, task_queue: str) -> int | None:
         """Return the advertised wait only for a complete poll-capacity refusal."""
         body = self.body

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/src/durable_workflow/worker.py

@@ -37,6 +37,8 @@ from functools import wraps
 from types import FunctionType
 from typing import Annotated, Any, Concatenate, Literal, ParamSpec, TypeVar, Union, get_args, get_origin, get_type_hints
 
+import httpx
+
 from . import serializer
 from ._activity_lease import activity_lease_renewal_supported, current_activity_authority
 from ._activity_process import CallbackFailure, CallbackInvocation, CallbackProcessLost, SupervisedCallback
@@ -1169,6 +1171,10 @@ class Worker:
         self._in_flight: set[asyncio.Task[Any]] = set()
         self._poller_tasks: set[asyncio.Task[Any]] = set()
         self._registered = False
+        self._deregistration_fenced = False
+        self._registration_token: str | None = None
+        self._registration_worker_id: str | None = None
+        self._registration_namespace: object = None
         self._run_started = False
         self._registration_done = asyncio.Event()
         self._shutdown_task: asyncio.Task[None] | None = None
@@ -1295,6 +1301,18 @@ class Worker:
         _validate_server_compatibility(info)
         protocol = info.get("worker_protocol")
         server_capabilities = protocol.get("server_capabilities") if isinstance(protocol, Mapping) else None
+        deregistration = (
+            server_capabilities.get("worker_deregistration_fencing")
+            if isinstance(server_capabilities, Mapping) else None
+        )
+        self._deregistration_fenced = isinstance(deregistration, Mapping) and deregistration.get("supported") is True
+        if isinstance(deregistration, Mapping) and self._deregistration_fenced and (
+            deregistration.get("schema") != "durable-workflow.v2.worker-deregistration.v1"
+            or deregistration.get("endpoint") != "/worker/registrations/{workerId}/deregister"
+            or type(deregistration.get("receipt_retention_seconds")) is not int
+            or deregistration["receipt_retention_seconds"] <= 0
+        ):
+            raise RuntimeError("Server compatibility error: invalid worker_deregistration_fencing contract")
         sticky_support = (
             server_capabilities.get("sticky_execution") if isinstance(server_capabilities, Mapping) else None
         )
@@ -1449,6 +1467,20 @@ class Worker:
             task_slots=self._current_task_slots(),
             process_metrics=self._current_process_metrics(),
         )
+        if self._deregistration_fenced:
+            token = ack.get("registration_token") if isinstance(ack, dict) else None
+            if (
+                not isinstance(token, str) or len(token) != 32
+                or any(character not in "0123456789abcdef" for character in token)
+                or ack.get("worker_id") != self.worker_id or ack.get("registered") is not True
+            ):
+                raise RuntimeError(
+                    "Server returned an invalid registration_token acknowledgement; "
+                    "registration may remain active and unfenced cleanup is unsafe"
+                )
+            self._registration_token = token
+        self._registration_worker_id = self.worker_id
+        self._registration_namespace = getattr(self.client, "namespace", None)
         self._registered = True
         # Adapt to the server-advertised cadence when present so a cluster
         # can pin the worker fleet's heartbeat beat without each worker
@@ -4567,8 +4599,9 @@ class Worker:
     async def stop(self) -> None:
         """Stop polling, drain tasks, and remove the worker registration.
 
-        Repeated calls share one shutdown result. A failed deregistration is
-        therefore propagated to every caller without sending another DELETE.
+        Repeated calls share one shutdown result. Generation-fenced recovery
+        stays within the original shutdown deadline. Unfenced deregistration
+        makes one attempt and does not retry an uncertain outcome.
         """
         self._stop.set()
         if self._shutdown_task is None:
@@ -4664,8 +4697,9 @@ class Worker:
                 log.warning("worker session %s close failed: %s", session.options.session_id, error)
 
         if self._registered:
-            await self.client.deregister_worker_registration(self.worker_id)
+            await self._deregister_before_deadline(deadline)
             self._registered = False
+            self._registration_token = None
             log.info("worker %s deregistered", self.worker_id)
         self._sticky_cache.clear()
         payload_observers = getattr(self.client, "_workflow_payload_observers", None)
@@ -4676,3 +4710,62 @@ class Worker:
     @staticmethod
     def _remaining_shutdown_time(deadline: float) -> float:
         return max(0.0, deadline - asyncio.get_running_loop().time())
+
+    def _check_deregistration_identity(self) -> None:
+        if self._deregistration_fenced and self._registration_token is None:
+            raise RuntimeError("worker registration token is missing; registration removal is unconfirmed")
+        if self._registration_worker_id is not None and (
+            self.worker_id != self._registration_worker_id
+            or getattr(self.client, "namespace", None) != self._registration_namespace
+        ):
+            raise RuntimeError("worker registration identity changed; registration removal is unconfirmed")
+
+    async def _deregistration_attempt(self, remaining: float) -> tuple[float | None, Exception] | None:
+        kwargs: dict[str, Any] = {}
+        if self._deregistration_fenced:
+            kwargs = {"registration_token": self._registration_token, "timeout": remaining}
+        if isinstance(self._registration_namespace, str):
+            kwargs["expected_namespace"] = self._registration_namespace
+        try:
+            await asyncio.wait_for(
+                self.client.deregister_worker_registration(self.worker_id, **kwargs),
+                timeout=remaining,
+            )
+        except asyncio.TimeoutError as error:
+            raise RuntimeError(
+                "worker shutdown timed out during deregistration; registration removal is unconfirmed"
+            ) from error
+        except ServerError as error:
+            retry_delay = (
+                error.worker_deregistration_retry_delay(self.worker_id, self._registration_token)
+                if self._deregistration_fenced and self._registration_token is not None else None
+            )
+            if retry_delay is None:
+                raise
+            return float(retry_delay), error
+        except (httpx.NetworkError, httpx.TimeoutException, httpx.RemoteProtocolError) as error:
+            if not self._deregistration_fenced:
+                raise
+            return None, error
+        return None
+
+    async def _deregister_before_deadline(self, deadline: float) -> None:
+        attempt = 0
+        while True:
+            self._check_deregistration_identity()
+            remaining = self._remaining_shutdown_time(deadline)
+            if remaining <= 0:
+                raise RuntimeError("worker shutdown deadline exhausted; registration removal is unconfirmed")
+            retry = await self._deregistration_attempt(remaining)
+            if retry is None:
+                return
+            retry_delay, failure = retry
+            delay = min(1.0, 0.1 * 2 ** min(attempt, 4)) if retry_delay is None else retry_delay
+            if delay >= self._remaining_shutdown_time(deadline):
+                raise RuntimeError(
+                    "worker shutdown cannot retry within its deadline; registration removal is unconfirmed"
+                ) from failure
+            if attempt == 0:
+                log.warning("worker deregistration is unconfirmed; retrying the fenced request within its deadline")
+            attempt += 1
+            await asyncio.sleep(delay)

{durable_workflow-2.10.0 → durable_workflow-2.10.1/src/durable_workflow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: durable-workflow
-Version: 2.10.0
+Version: 2.10.1
 Summary: Python client and worker SDK for Durable Workflow Cloud and self-hosted Server
 Author: Durable Workflow Contributors
 License-Expression: MIT

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/src/durable_workflow.egg-info/SOURCES.txt

@@ -146,6 +146,7 @@ tests/test_update_signal_condition_replay.py
 tests/test_updates.py
 tests/test_wait_condition.py
 tests/test_worker.py
+tests/test_worker_deregistration.py
 tests/test_worker_observation.py
 tests/test_worker_session.py
 tests/test_worker_telemetry_wire.py

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/tests/test_cooperative_cancellation_worker.py

@@ -607,8 +607,12 @@ async def test_shutdown_timeout_abandons_cleanup_and_replacement_replays_origina
     await asyncio.wait_for(entered.wait(), timeout=1)
     original_history = deepcopy(server.history)
     heartbeats_before_stop = server.client.heartbeat_workflow_task.await_count
-    await asyncio.wait_for(worker.stop(), timeout=1)
-    release_thread.set()
+    stopping = worker.stop()
+    try:
+        with pytest.raises(RuntimeError, match="deadline exhausted.*registration.*unconfirmed"):
+            await asyncio.wait_for(stopping, timeout=1)
+    finally:
+        release_thread.set()
     await asyncio.wait_for(discarded.wait(), timeout=1)
     assert fenced_heartbeats == [True]
     assert server.client.heartbeat_workflow_task.await_count == heartbeats_before_stop
@@ -616,7 +620,8 @@ async def test_shutdown_timeout_abandons_cleanup_and_replacement_replays_origina
     assert server.history == original_history
     server.client.complete_workflow_task.assert_not_awaited()
     server.client.fail_workflow_task.assert_not_awaited()
-    server.client.deregister_worker_registration.assert_awaited_once_with("cooperative-worker")
+    assert worker._registered
+    server.client.deregister_worker_registration.assert_not_awaited()
 
     replacement = ClaimServer(history=original_history, lease_owner="replacement-worker", workflow_task_attempt=5)
     cleanup_ids: list[str] = []

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/tests/test_cooperative_remote_worker.py

@@ -92,8 +92,7 @@ async def application_failure(kind: str) -> None:
     raise ActivityCancelled()
 
 
-@pytest_asyncio.fixture
-async def owner(monkeypatch: pytest.MonkeyPatch):  # type: ignore[no-untyped-def]
+async def make_owner(monkeypatch: pytest.MonkeyPatch) -> tuple[Worker, AsyncMock]:
     monkeypatch.delenv("DURABLE_WORKFLOW_WORKER_PROTOCOL_VERSION", raising=False)
     client = AsyncMock(spec=Client)
     client.get_cluster_info.return_value = compatible_cluster_info(worker_protocol={
@@ -106,6 +105,12 @@ async def owner(monkeypatch: pytest.MonkeyPatch):  # type: ignore[no-untyped-def
     worker = Worker(client, task_queue="queue", worker_id="owner", capabilities=["cooperative_cancellation"],
                     max_concurrent_activity_tasks=1)
     await worker._register()
+    return worker, client
+
+
+@pytest_asyncio.fixture
+async def owner(monkeypatch: pytest.MonkeyPatch):  # type: ignore[no-untyped-def]
+    worker, client = await make_owner(monkeypatch)
     try:
         yield worker, client
     finally:
@@ -152,18 +157,27 @@ async def test_authority_loss_stops_and_joins_the_actual_callback_before_reporti
     client.fail_activity_task.assert_not_awaited()
 
 
-async def test_shutdown_timeout_joins_the_remote_callback_before_returning(owner: Any, tmp_path: Path) -> None:
-    worker, client = owner
+async def test_shutdown_timeout_joins_the_remote_callback_before_returning(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
+) -> None:
+    worker, client = await make_owner(monkeypatch)
     worker._shutdown_timeout = 0.01
     marker = tmp_path / "callback"
     worker.activities["remote"] = blocked_async
     execution = worker._track(worker._run_activity_task(task(str(marker))))
     await wait_for_file(marker)
     pid = int(marker.read_text())
-    await asyncio.wait_for(worker.stop(), timeout=4.0)
+    stopping = worker.stop()
+    with pytest.raises(RuntimeError, match="deadline exhausted.*registration.*unconfirmed") as failed:
+        await asyncio.wait_for(stopping, timeout=4.0)
     await wait_for_exit(pid)
     assert execution.cancelled() or execution.result() == "claim_aborted"
     assert not worker._remote_activity_processes
+    assert worker._registered
+    client.deregister_worker_registration.assert_not_awaited()
+    with pytest.raises(RuntimeError) as repeated:
+        await worker.stop()
+    assert repeated.value is failed.value
     client.complete_activity_task.assert_not_awaited()
     client.fail_activity_task.assert_not_awaited()
 

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/tests/test_replay_regression_corpus.py

@@ -25,6 +25,7 @@ from durable_workflow.workflow import (
     commands_to_server_commands,
     query_state,
 )
+from tests.deregistration_recovery import RecoveredWorkflow as FencedRecoveryWorkflow
 from tests.test_condition_replay_drift import ConditionIdentityWorkflow
 from tests.test_golden_history_replay import (
     GoldenSagaCompensationWorkflow,
@@ -371,6 +372,7 @@ WORKFLOWS = [
     RepeatedPatchWorkflow,
     PendingOperation,
     RecoveredWorkflow,
+    FencedRecoveryWorkflow,
     PagedRecordedSideEffectsWorkflow,
     PostConditionReceiversWorkflow,
     RecordedSideEffectWorkflow,

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/tests/test_storage_admission.py

@@ -8,6 +8,7 @@ from contextlib import contextmanager
 from pathlib import Path
 from types import SimpleNamespace
 from typing import Any
+from urllib.parse import unquote
 
 import httpx
 import pytest
@@ -544,7 +545,12 @@ async def test_running_worker_preserves_activity_outcome_without_reexecution(
             info = compatible_cluster_info()
             info["worker_protocol"]["server_capabilities"]["query_tasks"] = False
             return httpx.Response(200, json=info)
-        if path.endswith("/register") or request.method == "DELETE":
+        if request.method == "DELETE":
+            return httpx.Response(200, json={
+                "worker_id": unquote(path.rsplit("/", 1)[-1]),
+                "outcome": "deregistered", "recovered_workflow_task_count": 0,
+            })
+        if path.endswith("/register"):
             return httpx.Response(200, json={"registered": True})
         if path.endswith("/activity-tasks/poll"):
             claims += 1
@@ -656,7 +662,10 @@ async def test_run_until_timeout_interrupts_storage_pressure(phase: str) -> None
             return httpx.Response(200, json=info)
         if request.method == "DELETE":
             deregistered += 1
-            return httpx.Response(200, json={})
+            return httpx.Response(200, json={
+                "worker_id": unquote(path.rsplit("/", 1)[-1]),
+                "outcome": "deregistered", "recovered_workflow_task_count": 0,
+            })
         if (
             (phase == "registration" and path.endswith("/register"))
             or (phase == "poll" and path.endswith("/poll"))
@@ -813,7 +822,12 @@ async def test_cold_replay_completion_retries_only_its_prepared_acknowledgement(
             info = compatible_cluster_info()
             info["worker_protocol"]["server_capabilities"]["query_tasks"] = False
             return httpx.Response(200, json=info)
-        if path.endswith("/register") or request.method == "DELETE":
+        if request.method == "DELETE":
+            return httpx.Response(200, json={
+                "worker_id": unquote(path.rsplit("/", 1)[-1]),
+                "outcome": "deregistered", "recovered_workflow_task_count": 0,
+            })
+        if path.endswith("/register"):
             return httpx.Response(200, json={})
         if path.endswith("/workflows/cold-replay"):
             return httpx.Response(200, json={"status": "completed" if completed else "running"})

{durable_workflow-2.10.0 → durable_workflow-2.10.1}/tests/test_worker.py

@@ -3226,7 +3226,7 @@ class TestUpdateValidationTaskExecution:
         assert worker._current_task_slots()["workflow_available"] == 1
 
     @pytest.mark.asyncio
-    async def test_shutdown_cancels_validation_and_deregisters_after_releasing_capacity(
+    async def test_shutdown_releases_validation_capacity_without_deregistering_after_deadline(
         self, mock_client: AsyncMock
     ) -> None:
         validation_started = asyncio.Event()
@@ -3279,15 +3279,16 @@ class TestUpdateValidationTaskExecution:
         await asyncio.wait_for(validation_started.wait(), timeout=1.0)
         assert worker._current_task_slots()["workflow_available"] == 0
 
-        await worker.stop()
+        with pytest.raises(RuntimeError, match="deadline exhausted.*registration.*unconfirmed"):
+            await worker.stop()
 
         assert validation_cancelled.is_set()
         assert worker._workflow_inflight == 0
         assert worker._workflow_reserved == 0
         assert worker._wf_semaphore._value == 1
         assert worker._current_task_slots()["workflow_available"] == 1
-        assert worker._registered is False
-        mock_client.deregister_worker_registration.assert_awaited_once_with(worker.worker_id)
+        assert worker._registered is True
+        mock_client.deregister_worker_registration.assert_not_awaited()
 
     @pytest.mark.asyncio
     async def test_cancellation_before_dispatch_starts_releases_admitted_capacity(self, mock_client: AsyncMock) -> None:
@@ -4516,7 +4517,7 @@ class TestWorkerShutdown:
         mock_client.deregister_worker_registration.assert_awaited_once_with(worker.worker_id)
 
     @pytest.mark.asyncio
-    async def test_shutdown_deadline_cancels_work_before_deregistering(
+    async def test_shutdown_deadline_cancels_work_without_sending_late_deregistration(
         self, mock_client: AsyncMock
     ) -> None:
         events: list[str] = []
@@ -4539,11 +4540,13 @@ class TestWorkerShutdown:
         tracked_task = worker._track(accepted_work())
         await work_started.wait()
 
-        await worker.stop()
+        with pytest.raises(RuntimeError, match="deadline exhausted.*registration.*unconfirmed"):
+            await worker.stop()
 
         assert tracked_task.cancelled()
-        assert events == ["work_cancelled", "deregister"]
-        mock_client.deregister_worker_registration.assert_awaited_once_with(worker.worker_id)
+        assert events == ["work_cancelled"]
+        assert worker._registered is True
+        mock_client.deregister_worker_registration.assert_not_awaited()
 
     @pytest.mark.asyncio
     async def test_failed_registration_does_not_deregister(self, mock_client: AsyncMock) -> None: