hatchet-sdk 0.46.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

hatchet_sdk/clients/admin.py

@@ -1,70 +1,56 @@
+import asyncio
 import json
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Optional, TypedDict, TypeVar, Union
+from typing import Union, cast
 
 import grpc
 from google.protobuf import timestamp_pb2
+from pydantic import BaseModel, Field
 
-from hatchet_sdk.clients.rest.models.workflow_run import WorkflowRun
 from hatchet_sdk.clients.rest.tenacity_utils import tenacity_retry
-from hatchet_sdk.clients.run_event_listener import new_listener
+from hatchet_sdk.clients.run_event_listener import RunEventListenerClient
 from hatchet_sdk.clients.workflow_listener import PooledWorkflowRunListener
+from hatchet_sdk.config import ClientConfig
 from hatchet_sdk.connection import new_conn
-from hatchet_sdk.contracts.workflows_pb2 import (
-    BulkTriggerWorkflowRequest,
-    BulkTriggerWorkflowResponse,
-    CreateWorkflowVersionOpts,
-    PutRateLimitRequest,
-    PutWorkflowRequest,
-    RateLimitDuration,
-    ScheduleWorkflowRequest,
-    TriggerWorkflowRequest,
-    TriggerWorkflowResponse,
-    WorkflowVersion,
-)
+from hatchet_sdk.contracts import workflows_pb2 as workflow_protos
 from hatchet_sdk.contracts.workflows_pb2_grpc import WorkflowServiceStub
-from hatchet_sdk.utils.serialization import flatten
-from hatchet_sdk.workflow_run import RunRef, WorkflowRunRef
-
-from ..loader import ClientConfig
-from ..metadata import get_metadata
-from ..workflow import WorkflowMeta
-
-
-def new_admin(config: ClientConfig):
-    return AdminClient(config)
-
-
-class ScheduleTriggerWorkflowOptions(TypedDict, total=False):
-    parent_id: Optional[str]
-    parent_step_run_id: Optional[str]
-    child_index: Optional[int]
-    child_key: Optional[str]
-    namespace: Optional[str]
+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, maybe_int_to_str
+from hatchet_sdk.utils.typing import JSONSerializableMapping
+from hatchet_sdk.workflow_run import WorkflowRunRef
+
+
+class ScheduleTriggerWorkflowOptions(BaseModel):
+    parent_id: str | None = None
+    parent_step_run_id: str | None = None
+    child_index: int | None = None
+    child_key: str | None = None
+    namespace: str | None = None
 
 
-class ChildTriggerWorkflowOptions(TypedDict, total=False):
-    additional_metadata: Dict[str, str] | None = None
-    sticky: bool | None = None
+class ChildTriggerWorkflowOptions(BaseModel):
+    additional_metadata: JSONSerializableMapping = Field(default_factory=dict)
+    sticky: bool = False
 
 
-class ChildWorkflowRunDict(TypedDict, total=False):
+class ChildWorkflowRunDict(BaseModel):
     workflow_name: str
-    input: Any
+    input: JSONSerializableMapping
     options: ChildTriggerWorkflowOptions
     key: str | None = None
 
 
-class TriggerWorkflowOptions(ScheduleTriggerWorkflowOptions, total=False):
-    additional_metadata: Dict[str, str] | None = None
+class TriggerWorkflowOptions(ScheduleTriggerWorkflowOptions):
+    additional_metadata: JSONSerializableMapping = Field(default_factory=dict)
     desired_worker_id: str | None = None
     namespace: str | None = None
 
 
-class WorkflowRunDict(TypedDict, total=False):
+class WorkflowRunDict(BaseModel):
     workflow_name: str
-    input: Any
-    options: TriggerWorkflowOptions | None
+    input: JSONSerializableMapping
+    options: TriggerWorkflowOptions
 
 
 class DedupeViolationErr(Exception):
@@ -73,31 +59,41 @@ class DedupeViolationErr(Exception):
     pass
 
 
-class AdminClientBase:
-    pooled_workflow_listener: PooledWorkflowRunListener | None = None
+class AdminClient:
+    def __init__(self, config: ClientConfig):
+        conn = new_conn(config, False)
+        self.config = config
+        self.client = WorkflowServiceStub(conn)  # type: ignore[no-untyped-call]
+        self.token = config.token
+        self.listener_client = RunEventListenerClient(config=config)
+        self.namespace = config.namespace
+
+        self.pooled_workflow_listener: PooledWorkflowRunListener | None = None
 
     def _prepare_workflow_request(
-        self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
-    ):
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        options: TriggerWorkflowOptions,
+    ) -> workflow_protos.TriggerWorkflowRequest:
         try:
             payload_data = json.dumps(input)
+            _options = options.model_dump()
+
+            _options.pop("namespace")
 
             try:
-                meta = (
-                    None
-                    if options is None or "additional_metadata" not in options
-                    else options["additional_metadata"]
-                )
-                if meta is not None:
-                    options = {
-                        **options,
-                        "additional_metadata": json.dumps(meta).encode("utf-8"),
-                    }
+                _options = {
+                    **_options,
+                    "additional_metadata": json.dumps(
+                        options.additional_metadata
+                    ).encode("utf-8"),
+                }
             except json.JSONDecodeError as e:
                 raise ValueError(f"Error encoding payload: {e}")
 
-            return TriggerWorkflowRequest(
-                name=workflow_name, input=payload_data, **(options or {})
+            return workflow_protos.TriggerWorkflowRequest(
+                name=workflow_name, input=payload_data, **_options
             )
         except json.JSONDecodeError as e:
             raise ValueError(f"Error encoding payload: {e}")
@@ -105,266 +101,135 @@ class AdminClientBase:
     def _prepare_put_workflow_request(
         self,
         name: str,
-        workflow: CreateWorkflowVersionOpts | WorkflowMeta,
-        overrides: CreateWorkflowVersionOpts | None = None,
-    ):
-        try:
-            opts: CreateWorkflowVersionOpts
-
-            if isinstance(workflow, CreateWorkflowVersionOpts):
-                opts = workflow
-            else:
-                opts = workflow.get_create_opts(self.client.config.namespace)
+        workflow: workflow_protos.CreateWorkflowVersionOpts,
+        overrides: workflow_protos.CreateWorkflowVersionOpts | None = None,
+    ) -> workflow_protos.PutWorkflowRequest:
+        if overrides is not None:
+            workflow.MergeFrom(overrides)
 
-            if overrides is not None:
-                opts.MergeFrom(overrides)
+        workflow.name = name
 
-            opts.name = name
+        return workflow_protos.PutWorkflowRequest(
+            opts=workflow,
+        )
 
-            return PutWorkflowRequest(
-                opts=opts,
+    def _parse_schedule(
+        self, schedule: datetime | timestamp_pb2.Timestamp
+    ) -> timestamp_pb2.Timestamp:
+        if isinstance(schedule, datetime):
+            t = schedule.timestamp()
+            seconds = int(t)
+            nanos = int(t % 1 * 1e9)
+            return timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos)
+        elif isinstance(schedule, timestamp_pb2.Timestamp):
+            return schedule
+        else:
+            raise ValueError(
+                "Invalid schedule type. Must be datetime or timestamp_pb2.Timestamp."
             )
-        except grpc.RpcError as e:
-            raise ValueError(f"Could not put workflow: {e}")
 
     def _prepare_schedule_workflow_request(
         self,
         name: str,
-        schedules: List[Union[datetime, timestamp_pb2.Timestamp]],
-        input={},
-        options: ScheduleTriggerWorkflowOptions = None,
-    ):
-        timestamp_schedules = []
-        for schedule in schedules:
-            if isinstance(schedule, datetime):
-                t = schedule.timestamp()
-                seconds = int(t)
-                nanos = int(t % 1 * 1e9)
-                timestamp = timestamp_pb2.Timestamp(seconds=seconds, nanos=nanos)
-                timestamp_schedules.append(timestamp)
-            elif isinstance(schedule, timestamp_pb2.Timestamp):
-                timestamp_schedules.append(schedule)
-            else:
-                raise ValueError(
-                    "Invalid schedule type. Must be datetime or timestamp_pb2.Timestamp."
-                )
-
-        return ScheduleWorkflowRequest(
+        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
+        input: JSONSerializableMapping = {},
+        options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
+    ) -> workflow_protos.ScheduleWorkflowRequest:
+        return workflow_protos.ScheduleWorkflowRequest(
             name=name,
-            schedules=timestamp_schedules,
+            schedules=[self._parse_schedule(schedule) for schedule in schedules],
             input=json.dumps(input),
-            **(options or {}),
-        )
-
-
-T = TypeVar("T")
-
-
-class AdminClientAioImpl(AdminClientBase):
-    def __init__(self, config: ClientConfig):
-        aio_conn = new_conn(config, True)
-        self.config = config
-        self.aio_client = WorkflowServiceStub(aio_conn)
-        self.token = config.token
-        self.listener_client = new_listener(config)
-        self.namespace = config.namespace
-
-    async def run(
-        self,
-        function: Union[str, Callable[[Any], T]],
-        input: any,
-        options: TriggerWorkflowOptions = None,
-    ) -> "RunRef[T]":
-        workflow_name = function
-
-        if not isinstance(function, str):
-            workflow_name = function.function_name
-
-        wrr = await self.run_workflow(workflow_name, input, options)
-
-        return RunRef[T](
-            wrr.workflow_run_id, wrr.workflow_listener, wrr.workflow_run_event_listener
+            **options.model_dump(),
         )
 
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
-    async def run_workflow(
-        self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
+    async def aio_run_workflow(
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunRef:
-        try:
-            if not self.pooled_workflow_listener:
-                self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
-
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options.pop("namespace")
-
-            if namespace != "" and not workflow_name.startswith(self.namespace):
-                workflow_name = f"{namespace}{workflow_name}"
-
-            request = self._prepare_workflow_request(workflow_name, input, options)
-
-            resp: TriggerWorkflowResponse = await self.aio_client.TriggerWorkflow(
-                request,
-                metadata=get_metadata(self.token),
-            )
-
-            return WorkflowRunRef(
-                workflow_run_id=resp.workflow_run_id,
-                workflow_listener=self.pooled_workflow_listener,
-                workflow_run_event_listener=self.listener_client,
-            )
-        except (grpc.RpcError, grpc.aio.AioRpcError) as e:
-            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                raise DedupeViolationErr(e.details())
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-            raise e
+        return await asyncio.to_thread(self.run_workflow, workflow_name, input, options)
 
-    ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
-    async def run_workflows(
+    async def aio_run_workflows(
         self,
         workflows: list[WorkflowRunDict],
-        options: TriggerWorkflowOptions | None = None,
-    ) -> List[WorkflowRunRef]:
-        if len(workflows) == 0:
-            raise ValueError("No workflows to run")
-
+        options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
+    ) -> list[WorkflowRunRef]:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
         if not self.pooled_workflow_listener:
             self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        namespace = self.namespace
-
-        if (
-            options is not None
-            and "namespace" in options
-            and options["namespace"] is not None
-        ):
-            namespace = options["namespace"]
-            del options["namespace"]
-
-        workflow_run_requests: TriggerWorkflowRequest = []
-
-        for workflow in workflows:
-            workflow_name = workflow["workflow_name"]
-            input_data = workflow["input"]
-            options = workflow["options"]
-
-            if namespace != "" and not workflow_name.startswith(self.namespace):
-                workflow_name = f"{namespace}{workflow_name}"
-
-            # Prepare and trigger workflow for each workflow name and input
-            request = self._prepare_workflow_request(workflow_name, input_data, options)
-            workflow_run_requests.append(request)
-
-        request = BulkTriggerWorkflowRequest(workflows=workflow_run_requests)
-
-        resp: BulkTriggerWorkflowResponse = await self.aio_client.BulkTriggerWorkflow(
-            request,
-            metadata=get_metadata(self.token),
-        )
-
-        return [
-            WorkflowRunRef(
-                workflow_run_id=workflow_run_id,
-                workflow_listener=self.pooled_workflow_listener,
-                workflow_run_event_listener=self.listener_client,
-            )
-            for workflow_run_id in resp.workflow_run_ids
-        ]
+        return await asyncio.to_thread(self.run_workflows, workflows, options)
 
     @tenacity_retry
-    async def put_workflow(
+    async def aio_put_workflow(
         self,
         name: str,
-        workflow: CreateWorkflowVersionOpts | WorkflowMeta,
-        overrides: CreateWorkflowVersionOpts | None = None,
-    ) -> WorkflowVersion:
-        opts = self._prepare_put_workflow_request(name, workflow, overrides)
+        workflow: workflow_protos.CreateWorkflowVersionOpts,
+        overrides: workflow_protos.CreateWorkflowVersionOpts | None = None,
+    ) -> workflow_protos.WorkflowVersion:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        return await self.aio_client.PutWorkflow(
-            opts,
-            metadata=get_metadata(self.token),
-        )
+        return await asyncio.to_thread(self.put_workflow, name, workflow, overrides)
 
     @tenacity_retry
-    async def put_rate_limit(
+    async def aio_put_rate_limit(
         self,
         key: str,
         limit: int,
         duration: RateLimitDuration = RateLimitDuration.SECOND,
-    ):
-        await self.aio_client.PutRateLimit(
-            PutRateLimitRequest(
-                key=key,
-                limit=limit,
-                duration=duration,
-            ),
-            metadata=get_metadata(self.token),
-        )
+    ) -> None:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
+
+        return await asyncio.to_thread(self.put_rate_limit, key, limit, duration)
 
     @tenacity_retry
-    async def schedule_workflow(
+    async def aio_schedule_workflow(
         self,
         name: str,
-        schedules: List[Union[datetime, timestamp_pb2.Timestamp]],
-        input={},
-        options: ScheduleTriggerWorkflowOptions = None,
-    ) -> WorkflowVersion:
-        try:
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options["namespace"]
-                del options["namespace"]
-
-            if namespace != "" and not name.startswith(self.namespace):
-                name = f"{namespace}{name}"
-
-            request = self._prepare_schedule_workflow_request(
-                name, schedules, input, options
-            )
-
-            return await self.aio_client.ScheduleWorkflow(
-                request,
-                metadata=get_metadata(self.token),
-            )
-        except (grpc.aio.AioRpcError, grpc.RpcError) as e:
-            if e.code() == grpc.StatusCode.ALREADY_EXISTS:
-                raise DedupeViolationErr(e.details())
-
-            raise e
-
+        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
+        input: JSONSerializableMapping = {},
+        options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
+    ) -> workflow_protos.WorkflowVersion:
+        ## IMPORTANT: The `pooled_workflow_listener` must be created 1) lazily, and not at `init` time, and 2) on the
+        ## main thread. If 1) is not followed, you'll get an error about something being attached to the wrong event
+        ## loop. If 2) is not followed, you'll get an error about the event loop not being set up.
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-class AdminClient(AdminClientBase):
-    def __init__(self, config: ClientConfig):
-        conn = new_conn(config)
-        self.config = config
-        self.client = WorkflowServiceStub(conn)
-        self.aio = AdminClientAioImpl(config)
-        self.token = config.token
-        self.listener_client = new_listener(config)
-        self.namespace = config.namespace
+        return await asyncio.to_thread(
+            self.schedule_workflow, name, schedules, input, options
+        )
 
     @tenacity_retry
     def put_workflow(
         self,
         name: str,
-        workflow: CreateWorkflowVersionOpts | WorkflowMeta,
-        overrides: CreateWorkflowVersionOpts | None = None,
-    ) -> WorkflowVersion:
+        workflow: workflow_protos.CreateWorkflowVersionOpts,
+        overrides: workflow_protos.CreateWorkflowVersionOpts | None = None,
+    ) -> workflow_protos.WorkflowVersion:
         opts = self._prepare_put_workflow_request(name, workflow, overrides)
 
-        resp: WorkflowVersion = self.client.PutWorkflow(
+        resp: workflow_protos.WorkflowVersion = self.client.PutWorkflow(
             opts,
             metadata=get_metadata(self.token),
         )
@@ -376,13 +241,16 @@ class AdminClient(AdminClientBase):
         self,
         key: str,
         limit: int,
-        duration: Union[RateLimitDuration.Value, str] = RateLimitDuration.SECOND,
-    ):
+        duration: RateLimitDuration = RateLimitDuration.SECOND,
+    ) -> None:
+        duration_proto = convert_python_enum_to_proto(
+            duration, workflow_protos.RateLimitDuration
+        )
         self.client.PutRateLimit(
-            PutRateLimitRequest(
+            workflow_protos.PutRateLimitRequest(
                 key=key,
                 limit=limit,
-                duration=duration,
+                duration=maybe_int_to_str(duration_proto),
             ),
             metadata=get_metadata(self.token),
         )
@@ -391,20 +259,12 @@ class AdminClient(AdminClientBase):
     def schedule_workflow(
         self,
         name: str,
-        schedules: List[Union[datetime, timestamp_pb2.Timestamp]],
-        input={},
-        options: ScheduleTriggerWorkflowOptions = None,
-    ) -> WorkflowVersion:
+        schedules: list[Union[datetime, timestamp_pb2.Timestamp]],
+        input: JSONSerializableMapping = {},
+        options: ScheduleTriggerWorkflowOptions = ScheduleTriggerWorkflowOptions(),
+    ) -> workflow_protos.WorkflowVersion:
         try:
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options["namespace"]
-                del options["namespace"]
+            namespace = options.namespace or self.namespace
 
             if namespace != "" and not name.startswith(self.namespace):
                 name = f"{namespace}{name}"
@@ -413,9 +273,12 @@ class AdminClient(AdminClientBase):
                 name, schedules, input, options
             )
 
-            return self.client.ScheduleWorkflow(
-                request,
-                metadata=get_metadata(self.token),
+            return cast(
+                workflow_protos.WorkflowVersion,
+                self.client.ScheduleWorkflow(
+                    request,
+                    metadata=get_metadata(self.token),
+                ),
             )
         except (grpc.RpcError, grpc.aio.AioRpcError) as e:
             if e.code() == grpc.StatusCode.ALREADY_EXISTS:
@@ -426,30 +289,28 @@ class AdminClient(AdminClientBase):
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     def run_workflow(
-        self, workflow_name: str, input: any, options: TriggerWorkflowOptions = None
+        self,
+        workflow_name: str,
+        input: JSONSerializableMapping,
+        options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> WorkflowRunRef:
         try:
             if not self.pooled_workflow_listener:
                 self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-            namespace = self.namespace
-
-            ## TODO: Factor this out - it's repeated a lot of places
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options.pop("namespace")
+            namespace = options.namespace or self.namespace
 
             if namespace != "" and not workflow_name.startswith(self.namespace):
                 workflow_name = f"{namespace}{workflow_name}"
 
             request = self._prepare_workflow_request(workflow_name, input, options)
 
-            resp: TriggerWorkflowResponse = self.client.TriggerWorkflow(
-                request,
-                metadata=get_metadata(self.token),
+            resp = cast(
+                workflow_protos.TriggerWorkflowResponse,
+                self.client.TriggerWorkflow(
+                    request,
+                    metadata=get_metadata(self.token),
+                ),
             )
 
             return WorkflowRunRef(
@@ -463,43 +324,43 @@ class AdminClient(AdminClientBase):
 
             raise e
 
+    def _prepare_workflow_run_request(
+        self, workflow: WorkflowRunDict, options: TriggerWorkflowOptions
+    ) -> workflow_protos.TriggerWorkflowRequest:
+        workflow_name = workflow.workflow_name
+        input_data = workflow.input
+        options = workflow.options
+
+        namespace = options.namespace or self.namespace
+
+        if namespace != "" and not workflow_name.startswith(self.namespace):
+            workflow_name = f"{namespace}{workflow_name}"
+
+        return self._prepare_workflow_request(workflow_name, input_data, options)
+
     ## IMPORTANT: Keep this method's signature in sync with the wrapper in the OTel instrumentor
     @tenacity_retry
     def run_workflows(
-        self, workflows: List[WorkflowRunDict], options: TriggerWorkflowOptions = None
+        self,
+        workflows: list[WorkflowRunDict],
+        options: TriggerWorkflowOptions = TriggerWorkflowOptions(),
     ) -> list[WorkflowRunRef]:
-        workflow_run_requests: TriggerWorkflowRequest = []
         if not self.pooled_workflow_listener:
             self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-        for workflow in workflows:
-            workflow_name = workflow["workflow_name"]
-            input_data = workflow["input"]
-            options = workflow["options"]
-
-            namespace = self.namespace
-
-            if (
-                options is not None
-                and "namespace" in options
-                and options["namespace"] is not None
-            ):
-                namespace = options["namespace"]
-                del options["namespace"]
-
-            if namespace != "" and not workflow_name.startswith(self.namespace):
-                workflow_name = f"{namespace}{workflow_name}"
-
-            # Prepare and trigger workflow for each workflow name and input
-            request = self._prepare_workflow_request(workflow_name, input_data, options)
-
-            workflow_run_requests.append(request)
-
-            request = BulkTriggerWorkflowRequest(workflows=workflow_run_requests)
+        bulk_request = workflow_protos.BulkTriggerWorkflowRequest(
+            workflows=[
+                self._prepare_workflow_run_request(workflow, options)
+                for workflow in workflows
+            ]
+        )
 
-        resp: BulkTriggerWorkflowResponse = self.client.BulkTriggerWorkflow(
-            request,
-            metadata=get_metadata(self.token),
+        resp = cast(
+            workflow_protos.BulkTriggerWorkflowResponse,
+            self.client.BulkTriggerWorkflow(
+                bulk_request,
+                metadata=get_metadata(self.token),
+            ),
         )
 
         return [
@@ -511,32 +372,12 @@ class AdminClient(AdminClientBase):
             for workflow_run_id in resp.workflow_run_ids
         ]
 
-    def run(
-        self,
-        function: Union[str, Callable[[Any], T]],
-        input: any,
-        options: TriggerWorkflowOptions = None,
-    ) -> "RunRef[T]":
-        workflow_name = function
-
-        if not isinstance(function, str):
-            workflow_name = function.function_name
-
-        wrr = self.run_workflow(workflow_name, input, options)
-
-        return RunRef[T](
-            wrr.workflow_run_id, wrr.workflow_listener, wrr.workflow_run_event_listener
-        )
-
     def get_workflow_run(self, workflow_run_id: str) -> WorkflowRunRef:
-        try:
-            if not self.pooled_workflow_listener:
-                self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
+        if not self.pooled_workflow_listener:
+            self.pooled_workflow_listener = PooledWorkflowRunListener(self.config)
 
-            return WorkflowRunRef(
-                workflow_run_id=workflow_run_id,
-                workflow_listener=self.pooled_workflow_listener,
-                workflow_run_event_listener=self.listener_client,
-            )
-        except grpc.RpcError as e:
-            raise ValueError(f"Could not get workflow run: {e}")
+        return WorkflowRunRef(
+            workflow_run_id=workflow_run_id,
+            workflow_listener=self.pooled_workflow_listener,
+            workflow_run_event_listener=self.listener_client,
+        )