hatchet-sdk 1.0.0a1__py3-none-any.whl → 1.0.1__py3-none-any.whl

hatchet_sdk/features/rate_limits.py

@@ -0,0 +1,45 @@
+import asyncio
+
+from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
+from hatchet_sdk.clients.v1.api_client import BaseRestClient
+from hatchet_sdk.connection import new_conn
+from hatchet_sdk.contracts import workflows_pb2 as v0_workflow_protos
+from hatchet_sdk.contracts.v1 import workflows_pb2 as workflow_protos
+from hatchet_sdk.contracts.workflows_pb2_grpc import WorkflowServiceStub
+from hatchet_sdk.metadata import get_metadata
+from hatchet_sdk.rate_limit import RateLimitDuration
+from hatchet_sdk.utils.proto_enums import convert_python_enum_to_proto
+
+
+class RateLimitsClient(BaseRestClient):
+    @tenacity_retry
+    def put(
+        self,
+        key: str,
+        limit: int,
+        duration: RateLimitDuration = RateLimitDuration.SECOND,
+    ) -> None:
+        duration_proto = convert_python_enum_to_proto(
+            duration, workflow_protos.RateLimitDuration
+        )
+
+        conn = new_conn(self.client_config, False)
+        client = WorkflowServiceStub(conn)  # type: ignore[no-untyped-call]
+
+        client.PutRateLimit(
+            v0_workflow_protos.PutRateLimitRequest(
+                key=key,
+                limit=limit,
+                duration=duration_proto,  # type: ignore[arg-type]
+            ),
+            metadata=get_metadata(self.client_config.token),
+        )
+
+    @tenacity_retry
+    async def aio_put(
+        self,
+        key: str,
+        limit: int,
+        duration: RateLimitDuration = RateLimitDuration.SECOND,
+    ) -> None:
+        await asyncio.to_thread(self.put, key, limit, duration)

hatchet_sdk/features/runs.py

@@ -0,0 +1,221 @@
+from datetime import datetime, timedelta
+from typing import Literal, overload
+
+from pydantic import BaseModel, model_validator
+
+from hatchet_sdk.clients.rest.api.task_api import TaskApi
+from hatchet_sdk.clients.rest.api.workflow_runs_api import WorkflowRunsApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.v1_cancel_task_request import V1CancelTaskRequest
+from hatchet_sdk.clients.rest.models.v1_replay_task_request import V1ReplayTaskRequest
+from hatchet_sdk.clients.rest.models.v1_task_filter import V1TaskFilter
+from hatchet_sdk.clients.rest.models.v1_task_status import V1TaskStatus
+from hatchet_sdk.clients.rest.models.v1_task_summary_list import V1TaskSummaryList
+from hatchet_sdk.clients.rest.models.v1_trigger_workflow_run_request import (
+    V1TriggerWorkflowRunRequest,
+)
+from hatchet_sdk.clients.rest.models.v1_workflow_run_details import V1WorkflowRunDetails
+from hatchet_sdk.clients.v1.api_client import (
+    BaseRestClient,
+    maybe_additional_metadata_to_kv,
+)
+from hatchet_sdk.utils.typing import JSONSerializableMapping
+
+
+class RunFilter(BaseModel):
+    since: datetime
+    until: datetime | None = None
+    statuses: list[V1TaskStatus] | None = None
+    workflow_ids: list[str] | None = None
+    additional_metadata: dict[str, str] | None = None
+
+
+class BulkCancelReplayOpts(BaseModel):
+    ids: list[str] | None = None
+    filters: RunFilter | None = None
+
+    @model_validator(mode="after")
+    def validate_model(self) -> "BulkCancelReplayOpts":
+        if not self.ids and not self.filters:
+            raise ValueError("ids or filters must be set")
+
+        if self.ids and self.filters:
+            raise ValueError("ids and filters cannot both be set")
+
+        return self
+
+    @property
+    def v1_task_filter(self) -> V1TaskFilter | None:
+        if not self.filters:
+            return None
+
+        return V1TaskFilter(
+            since=self.filters.since,
+            until=self.filters.until,
+            statuses=self.filters.statuses,
+            workflowIds=self.filters.workflow_ids,
+            additionalMetadata=maybe_additional_metadata_to_kv(
+                self.filters.additional_metadata
+            ),
+        )
+
+    @overload
+    def to_request(self, request_type: Literal["replay"]) -> V1ReplayTaskRequest: ...
+
+    @overload
+    def to_request(self, request_type: Literal["cancel"]) -> V1CancelTaskRequest: ...
+
+    def to_request(
+        self, request_type: Literal["replay", "cancel"]
+    ) -> V1ReplayTaskRequest | V1CancelTaskRequest:
+        if request_type == "replay":
+            return V1ReplayTaskRequest(
+                externalIds=self.ids,
+                filter=self.v1_task_filter,
+            )
+
+        if request_type == "cancel":
+            return V1CancelTaskRequest(
+                externalIds=self.ids,
+                filter=self.v1_task_filter,
+            )
+
+
+class RunsClient(BaseRestClient):
+    def _wra(self, client: ApiClient) -> WorkflowRunsApi:
+        return WorkflowRunsApi(client)
+
+    def _ta(self, client: ApiClient) -> TaskApi:
+        return TaskApi(client)
+
+    async def aio_get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
+        async with self.client() as client:
+            return await self._wra(client).v1_workflow_run_get(str(workflow_run_id))
+
+    def get(self, workflow_run_id: str) -> V1WorkflowRunDetails:
+        return self._run_async_from_sync(self.aio_get, workflow_run_id)
+
+    async def aio_list(
+        self,
+        since: datetime = datetime.now() - timedelta(hours=1),
+        only_tasks: bool = False,
+        offset: int | None = None,
+        limit: int | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        until: datetime | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+        worker_id: str | None = None,
+        parent_task_external_id: str | None = None,
+    ) -> V1TaskSummaryList:
+        async with self.client() as client:
+            return await self._wra(client).v1_workflow_run_list(
+                tenant=self.client_config.tenant_id,
+                since=since,
+                only_tasks=only_tasks,
+                offset=offset,
+                limit=limit,
+                statuses=statuses,
+                until=until,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                workflow_ids=workflow_ids,
+                worker_id=worker_id,
+                parent_task_external_id=parent_task_external_id,
+            )
+
+    def list(
+        self,
+        since: datetime = datetime.now() - timedelta(hours=1),
+        only_tasks: bool = False,
+        offset: int | None = None,
+        limit: int | None = None,
+        statuses: list[V1TaskStatus] | None = None,
+        until: datetime | None = None,
+        additional_metadata: dict[str, str] | None = None,
+        workflow_ids: list[str] | None = None,
+        worker_id: str | None = None,
+        parent_task_external_id: str | None = None,
+    ) -> V1TaskSummaryList:
+        return self._run_async_from_sync(
+            self.aio_list,
+            since=since,
+            only_tasks=only_tasks,
+            offset=offset,
+            limit=limit,
+            statuses=statuses,
+            until=until,
+            additional_metadata=additional_metadata,
+            workflow_ids=workflow_ids,
+            worker_id=worker_id,
+            parent_task_external_id=parent_task_external_id,
+        )
+
+    async def aio_create(
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        additional_metadata: JSONSerializableMapping = {},
+    ) -> V1WorkflowRunDetails:
+        async with self.client() as client:
+            return await self._wra(client).v1_workflow_run_create(
+                tenant=self.client_config.tenant_id,
+                v1_trigger_workflow_run_request=V1TriggerWorkflowRunRequest(
+                    workflowName=workflow_name,
+                    input=dict(input),
+                    additionalMetadata=dict(additional_metadata),
+                ),
+            )
+
+    def create(
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        additional_metadata: JSONSerializableMapping = {},
+    ) -> V1WorkflowRunDetails:
+        return self._run_async_from_sync(
+            self.aio_create, workflow_name, input, additional_metadata
+        )
+
+    async def aio_replay(self, run_id: str) -> None:
+        await self.aio_bulk_replay(opts=BulkCancelReplayOpts(ids=[run_id]))
+
+    def replay(self, run_id: str) -> None:
+        return self._run_async_from_sync(self.aio_replay, run_id)
+
+    async def aio_bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
+        async with self.client() as client:
+            await self._ta(client).v1_task_replay(
+                tenant=self.client_config.tenant_id,
+                v1_replay_task_request=opts.to_request("replay"),
+            )
+
+    def bulk_replay(self, opts: BulkCancelReplayOpts) -> None:
+        return self._run_async_from_sync(self.aio_bulk_replay, opts)
+
+    async def aio_cancel(self, run_id: str) -> None:
+        await self.aio_bulk_cancel(opts=BulkCancelReplayOpts(ids=[run_id]))
+
+    def cancel(self, run_id: str) -> None:
+        return self._run_async_from_sync(self.aio_cancel, run_id)
+
+    async def aio_bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
+        async with self.client() as client:
+            await self._ta(client).v1_task_cancel(
+                tenant=self.client_config.tenant_id,
+                v1_cancel_task_request=opts.to_request("cancel"),
+            )
+
+    def bulk_cancel(self, opts: BulkCancelReplayOpts) -> None:
+        return self._run_async_from_sync(self.aio_bulk_cancel, opts)
+
+    async def aio_get_result(self, run_id: str) -> JSONSerializableMapping:
+        details = await self.aio_get(run_id)
+
+        return details.run.output
+
+    def get_result(self, run_id: str) -> JSONSerializableMapping:
+        details = self.get(run_id)
+
+        return details.run.output

hatchet_sdk/features/scheduled.py

@@ -1,12 +1,13 @@
 import datetime
-from typing import List, Optional, Union
+from typing import Optional
 
-from pydantic import BaseModel, Field
-
-from hatchet_sdk.client import Client
-from hatchet_sdk.clients.rest.models.cron_workflows_order_by_field import (
-    CronWorkflowsOrderByField,
+from hatchet_sdk.clients.rest.api.workflow_api import WorkflowApi
+from hatchet_sdk.clients.rest.api.workflow_run_api import WorkflowRunApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.schedule_workflow_run_request import (
+    ScheduleWorkflowRunRequest,
 )
+from hatchet_sdk.clients.rest.models.scheduled_run_status import ScheduledRunStatus
 from hatchet_sdk.clients.rest.models.scheduled_workflows import ScheduledWorkflows
 from hatchet_sdk.clients.rest.models.scheduled_workflows_list import (
     ScheduledWorkflowsList,
@@ -17,43 +18,49 @@ from hatchet_sdk.clients.rest.models.scheduled_workflows_order_by_field import (
 from hatchet_sdk.clients.rest.models.workflow_run_order_by_direction import (
     WorkflowRunOrderByDirection,
 )
+from hatchet_sdk.clients.v1.api_client import (
+    BaseRestClient,
+    maybe_additional_metadata_to_kv,
+)
 from hatchet_sdk.utils.typing import JSONSerializableMapping
 
 
-class CreateScheduledTriggerConfig(BaseModel):
-    """
-    Schema for creating a scheduled workflow run.
-
-    Attributes:
-        input (JSONSerializableMapping): The input data for the scheduled workflow.
-        additional_metadata (JSONSerializableMapping): Additional metadata associated with the future run (e.g. ["key1:value1", "key2:value2"]).
-        trigger_at (Optional[datetime.datetime]): The datetime when the run should be triggered.
-    """
-
-    input: JSONSerializableMapping = Field(default_factory=dict)
-    additional_metadata: JSONSerializableMapping = Field(default_factory=dict)
-    trigger_at: datetime.datetime
-
-
-class ScheduledClient:
-    """
-    Client for managing scheduled workflows synchronously.
+class ScheduledClient(BaseRestClient):
+    def _wra(self, client: ApiClient) -> WorkflowRunApi:
+        return WorkflowRunApi(client)
 
-    Attributes:
-        _client (Client): The underlying client used to interact with the REST API.
-        aio (ScheduledClientAsync): Asynchronous counterpart of ScheduledClient.
-    """
+    def _wa(self, client: ApiClient) -> WorkflowApi:
+        return WorkflowApi(client)
 
-    _client: Client
-
-    def __init__(self, _client: Client) -> None:
+    async def aio_create(
+        self,
+        workflow_name: str,
+        trigger_at: datetime.datetime,
+        input: JSONSerializableMapping,
+        additional_metadata: JSONSerializableMapping,
+    ) -> ScheduledWorkflows:
         """
-        Initializes the ScheduledClient with a given Client instance.
+        Creates a new scheduled workflow run asynchronously.
 
         Args:
-            _client (Client): The client instance to be used for REST interactions.
+            workflow_name (str): The name of the scheduled workflow.
+            trigger_at (datetime.datetime): The datetime when the run should be triggered.
+            input (JSONSerializableMapping): The input data for the scheduled workflow.
+            additional_metadata (JSONSerializableMapping): Additional metadata associated with the future run.
+
+        Returns:
+            ScheduledWorkflows: The created scheduled workflow instance.
         """
-        self._client = _client
+        async with self.client() as client:
+            return await self._wra(client).scheduled_workflow_run_create(
+                tenant=self.client_config.tenant_id,
+                workflow=workflow_name,
+                schedule_workflow_run_request=ScheduleWorkflowRunRequest(
+                    triggerAt=trigger_at,
+                    input=dict(input),
+                    additionalMetadata=dict(additional_metadata),
+                ),
+            )
 
     def create(
         self,
@@ -75,37 +82,39 @@ class ScheduledClient:
             ScheduledWorkflows: The created scheduled workflow instance.
         """
 
-        validated_input = CreateScheduledTriggerConfig(
-            trigger_at=trigger_at, input=input, additional_metadata=additional_metadata
-        )
-
-        return self._client.rest.schedule_create(
+        return self._run_async_from_sync(
+            self.aio_create,
             workflow_name,
-            validated_input.trigger_at,
-            validated_input.input,
-            validated_input.additional_metadata,
+            trigger_at,
+            input,
+            additional_metadata,
         )
 
-    def delete(self, scheduled: Union[str, ScheduledWorkflows]) -> None:
+    async def aio_delete(self, scheduled_id: str) -> None:
         """
         Deletes a scheduled workflow run.
 
         Args:
-            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to delete.
+            scheduled_id (str): The scheduled workflow trigger ID to delete.
         """
-        self._client.rest.schedule_delete(
-            scheduled.metadata.id
-            if isinstance(scheduled, ScheduledWorkflows)
-            else scheduled
-        )
+        async with self.client() as client:
+            await self._wa(client).workflow_scheduled_delete(
+                tenant=self.client_config.tenant_id,
+                scheduled_workflow_run=scheduled_id,
+            )
 
-    def list(
+    def delete(self, scheduled_id: str) -> None:
+        self._run_async_from_sync(self.aio_delete, scheduled_id)
+
+    async def aio_list(
         self,
         offset: int | None = None,
         limit: int | None = None,
         workflow_id: str | None = None,
-        additional_metadata: Optional[List[str]] = None,
-        order_by_field: Optional[CronWorkflowsOrderByField] = None,
+        parent_workflow_run_id: str | None = None,
+        statuses: list[ScheduledRunStatus] | None = None,
+        additional_metadata: Optional[JSONSerializableMapping] = None,
+        order_by_field: Optional[ScheduledWorkflowsOrderByField] = None,
         order_by_direction: Optional[WorkflowRunOrderByDirection] = None,
     ) -> ScheduledWorkflowsList:
         """
@@ -115,120 +124,94 @@ class ScheduledClient:
             offset (int | None): The starting point for the list.
             limit (int | None): The maximum number of items to return.
             workflow_id (str | None): Filter by specific workflow ID.
-            additional_metadata (Optional[List[str]]): Filter by additional metadata keys (e.g. ["key1:value1", "key2:value2"]).
-            order_by_field (Optional[CronWorkflowsOrderByField]): Field to order the results by.
+            parent_workflow_run_id (str | None): Filter by parent workflow run ID.
+            statuses (list[ScheduledRunStatus] | None): Filter by status.
+            additional_metadata (Optional[List[dict[str, str]]]): Filter by additional metadata.
+            order_by_field (Optional[ScheduledWorkflowsOrderByField]): Field to order the results by.
             order_by_direction (Optional[WorkflowRunOrderByDirection]): Direction to order the results.
 
         Returns:
             List[ScheduledWorkflows]: A list of scheduled workflows matching the criteria.
         """
-        return self._client.rest.schedule_list(
-            offset=offset,
-            limit=limit,
-            workflow_id=workflow_id,
-            additional_metadata=additional_metadata,
-            order_by_field=order_by_field,
-            order_by_direction=order_by_direction,
-        )
-
-    def get(self, scheduled: Union[str, ScheduledWorkflows]) -> ScheduledWorkflows:
-        """
-        Retrieves a specific scheduled workflow by scheduled run trigger ID.
-
-        Args:
-            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to retrieve.
-
-        Returns:
-            ScheduledWorkflows: The requested scheduled workflow instance.
-        """
-        return self._client.rest.schedule_get(
-            scheduled.metadata.id
-            if isinstance(scheduled, ScheduledWorkflows)
-            else scheduled
-        )
-
-    async def aio_create(
-        self,
-        workflow_name: str,
-        trigger_at: datetime.datetime,
-        input: JSONSerializableMapping,
-        additional_metadata: JSONSerializableMapping,
-    ) -> ScheduledWorkflows:
-        """
-        Creates a new scheduled workflow run asynchronously.
+        async with self.client() as client:
+            return await self._wa(client).workflow_scheduled_list(
+                tenant=self.client_config.tenant_id,
+                offset=offset,
+                limit=limit,
+                order_by_field=order_by_field,
+                order_by_direction=order_by_direction,
+                workflow_id=workflow_id,
+                additional_metadata=maybe_additional_metadata_to_kv(
+                    additional_metadata
+                ),
+                parent_workflow_run_id=parent_workflow_run_id,
+                statuses=statuses,
+            )
 
-        Args:
-            workflow_name (str): The name of the scheduled workflow.
-            trigger_at (datetime.datetime): The datetime when the run should be triggered.
-            input (JSONSerializableMapping): The input data for the scheduled workflow.
-            additional_metadata (JSONSerializableMapping): Additional metadata associated with the future run.
-
-        Returns:
-            ScheduledWorkflows: The created scheduled workflow instance.
-        """
-        return await self._client.rest.aio_create_schedule(
-            workflow_name, trigger_at, input, additional_metadata
-        )
-
-    async def aio_delete(self, scheduled: Union[str, ScheduledWorkflows]) -> None:
-        """
-        Deletes a scheduled workflow asynchronously.
-
-        Args:
-            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to delete.
-        """
-        await self._client.rest.aio_delete_schedule(
-            scheduled.metadata.id
-            if isinstance(scheduled, ScheduledWorkflows)
-            else scheduled
-        )
-
-    async def aio_list(
+    def list(
         self,
         offset: int | None = None,
         limit: int | None = None,
         workflow_id: str | None = None,
-        additional_metadata: Optional[List[str]] = None,
+        parent_workflow_run_id: str | None = None,
+        statuses: list[ScheduledRunStatus] | None = None,
+        additional_metadata: Optional[JSONSerializableMapping] = None,
         order_by_field: Optional[ScheduledWorkflowsOrderByField] = None,
         order_by_direction: Optional[WorkflowRunOrderByDirection] = None,
     ) -> ScheduledWorkflowsList:
         """
-        Retrieves a list of scheduled workflows based on provided filters asynchronously.
+        Retrieves a list of scheduled workflows based on provided filters.
 
         Args:
             offset (int | None): The starting point for the list.
             limit (int | None): The maximum number of items to return.
             workflow_id (str | None): Filter by specific workflow ID.
-            additional_metadata (Optional[List[str]]): Filter by additional metadata keys (e.g. ["key1:value1", "key2:value2"]).
-            order_by_field (Optional[CronWorkflowsOrderByField]): Field to order the results by.
+            parent_workflow_run_id (str | None): Filter by parent workflow run ID.
+            statuses (list[ScheduledRunStatus] | None): Filter by status.
+            additional_metadata (Optional[List[dict[str, str]]]): Filter by additional metadata.
+            order_by_field (Optional[ScheduledWorkflowsOrderByField]): Field to order the results by.
             order_by_direction (Optional[WorkflowRunOrderByDirection]): Direction to order the results.
 
         Returns:
-            ScheduledWorkflowsList: A list of scheduled workflows matching the criteria.
+            List[ScheduledWorkflows]: A list of scheduled workflows matching the criteria.
         """
-        return await self._client.rest.aio_list_schedule(
+        return self._run_async_from_sync(
+            self.aio_list,
             offset=offset,
             limit=limit,
             workflow_id=workflow_id,
             additional_metadata=additional_metadata,
             order_by_field=order_by_field,
             order_by_direction=order_by_direction,
+            parent_workflow_run_id=parent_workflow_run_id,
+            statuses=statuses,
         )
 
-    async def aio_get(
-        self, scheduled: Union[str, ScheduledWorkflows]
-    ) -> ScheduledWorkflows:
+    async def aio_get(self, scheduled_id: str) -> ScheduledWorkflows:
+        """
+        Retrieves a specific scheduled workflow by scheduled run trigger ID.
+
+        Args:
+            scheduled (str): The scheduled workflow trigger ID to retrieve.
+
+        Returns:
+            ScheduledWorkflows: The requested scheduled workflow instance.
         """
-        Retrieves a specific scheduled workflow by scheduled run trigger ID asynchronously.
+
+        async with self.client() as client:
+            return await self._wa(client).workflow_scheduled_get(
+                tenant=self.client_config.tenant_id,
+                scheduled_workflow_run=scheduled_id,
+            )
+
+    def get(self, scheduled_id: str) -> ScheduledWorkflows:
+        """
+        Retrieves a specific scheduled workflow by scheduled run trigger ID.
 
         Args:
-            scheduled (Union[str, ScheduledWorkflows]): The scheduled workflow trigger ID or ScheduledWorkflows instance to retrieve.
+            scheduled (str): The scheduled workflow trigger ID to retrieve.
 
         Returns:
             ScheduledWorkflows: The requested scheduled workflow instance.
         """
-        return await self._client.rest.aio_get_schedule(
-            scheduled.metadata.id
-            if isinstance(scheduled, ScheduledWorkflows)
-            else scheduled
-        )
+        return self._run_async_from_sync(self.aio_get, scheduled_id)

hatchet_sdk/features/workers.py

@@ -0,0 +1,41 @@
+from hatchet_sdk.clients.rest.api.worker_api import WorkerApi
+from hatchet_sdk.clients.rest.api_client import ApiClient
+from hatchet_sdk.clients.rest.models.update_worker_request import UpdateWorkerRequest
+from hatchet_sdk.clients.rest.models.worker import Worker
+from hatchet_sdk.clients.rest.models.worker_list import WorkerList
+from hatchet_sdk.clients.v1.api_client import BaseRestClient
+
+
+class WorkersClient(BaseRestClient):
+    def _wa(self, client: ApiClient) -> WorkerApi:
+        return WorkerApi(client)
+
+    async def aio_get(self, worker_id: str) -> Worker:
+        async with self.client() as client:
+            return await self._wa(client).worker_get(worker_id)
+
+    def get(self, worker_id: str) -> Worker:
+        return self._run_async_from_sync(self.aio_get, worker_id)
+
+    async def aio_list(
+        self,
+    ) -> WorkerList:
+        async with self.client() as client:
+            return await self._wa(client).worker_list(
+                tenant=self.client_config.tenant_id,
+            )
+
+    def list(
+        self,
+    ) -> WorkerList:
+        return self._run_async_from_sync(self.aio_list)
+
+    async def aio_update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
+        async with self.client() as client:
+            return await self._wa(client).worker_update(
+                worker=worker_id,
+                update_worker_request=opts,
+            )
+
+    def update(self, worker_id: str, opts: UpdateWorkerRequest) -> Worker:
+        return self._run_async_from_sync(self.aio_update, worker_id, opts)