anyscale 0.26.20__py3-none-any.whl → 0.26.22__py3-none-any.whl

anyscale/_private/anyscale_client/anyscale_client.py

@@ -60,6 +60,8 @@ from anyscale.client.openapi_client.models import (
     Dataset as InternalDataset,
     DatasetUpload,
     DecoratedComputeTemplate,
+    DecoratedlistserviceapimodelListResponse,
+    DecoratedProductionServiceV2APIModel,
     DecoratedSession,
     DeletedPlatformFineTunedModel,
     ExperimentalWorkspace,
@@ -85,7 +87,7 @@ from anyscale.cluster_compute import parse_cluster_compute_name_version
 from anyscale.feature_flags import FLAG_DEFAULT_WORKING_DIR_FOR_PROJ
 from anyscale.sdk.anyscale_client.api.default_api import DefaultApi as ExternalApi
 from anyscale.sdk.anyscale_client.models import (
-    ApplyServiceModel,
+    ApplyProductionServiceV2Model,
     Cluster,
     ClusterCompute,
     ClusterComputeConfig,
@@ -102,7 +104,6 @@ from anyscale.sdk.anyscale_client.models import (
     ProductionServiceV2VersionModel,
     Project,
     RollbackServiceModel,
-    ServiceModel,
     TextQuery,
 )
 from anyscale.sdk.anyscale_client.models.jobs_query import JobsQuery
@@ -250,6 +251,7 @@ class AnyscaleClient(AnyscaleClientInterface):
         # Cached IDs and models to avoid duplicate lookups.
         self._default_project_id_from_cloud_id: Dict[Optional[str], str] = {}
         self._cloud_id_cache: Dict[Optional[str], str] = {}
+        self._cluster_env_build_cache: Dict[str, ClusterEnvironmentBuild] = {}
         self._current_workspace_cluster: Optional[Cluster] = None
         self._logger = logger or BlockLogger()
         self._host = host or ANYSCALE_HOST
@@ -715,16 +717,41 @@ class AnyscaleClient(AnyscaleClientInterface):
 
     @handle_api_exceptions
     def get_cluster_env_build(self, build_id: str) -> Optional[ClusterEnvironmentBuild]:
-        return self._external_api_client.get_cluster_environment_build(build_id).result
+        # Check cache first
+        if build_id in self._cluster_env_build_cache:
+            return self._cluster_env_build_cache[build_id]
+
+        # Fetch from API if not in cache
+        try:
+            res = self._external_api_client.get_cluster_environment_build(build_id)
+            build = res.result
+        except ExternalApiException as e:
+            if e.status == 404:
+                return None
+
+            raise e from None
+
+        # Store in cache ONLY if the build exists and is in a terminal state
+        if build:
+            terminal_states = {
+                ClusterEnvironmentBuildStatus.SUCCEEDED,
+                ClusterEnvironmentBuildStatus.FAILED,
+                ClusterEnvironmentBuildStatus.CANCELED,
+            }
+            if build.status in terminal_states:
+                self._cluster_env_build_cache[build_id] = build
+
+        return build
 
     @handle_api_exceptions
     def get_cluster_env_build_image_uri(
         self, cluster_env_build_id: str, use_image_alias: bool = False
     ) -> Optional[ImageURI]:
         try:
-            build: ClusterEnvironmentBuild = self._external_api_client.get_cluster_environment_build(
-                cluster_env_build_id
-            ).result
+            build = self.get_cluster_env_build(cluster_env_build_id)
+            if build is None:
+                return None
+
             cluster_env = self._external_api_client.get_cluster_environment(
                 build.cluster_environment_id
             ).result
@@ -786,9 +813,7 @@ class AnyscaleClient(AnyscaleClientInterface):
         """
         elapsed_secs = 0
         while elapsed_secs < timeout_secs:
-            build = self._external_api_client.get_cluster_environment_build(
-                build_id
-            ).result
+            build = self.get_cluster_env_build(build_id)
             if build.status == ClusterEnvironmentBuildStatus.SUCCEEDED:
                 self.logger.info("")
                 return
@@ -1001,35 +1026,60 @@ class AnyscaleClient(AnyscaleClientInterface):
         cloud: Optional[str],
         project: Optional[str],
         include_archived: bool = False,
-    ) -> Optional[ServiceModel]:
-        # TODO(edoakes): this endpoint is very slow and there's no reason we should need
-        # to use this complex list endpoint just to fetch a service by name.
-        paging_token = None
-        cloud_id = self.get_cloud_id(cloud_name=cloud)
-        project_id = self.get_project_id(parent_cloud_id=cloud_id, name=project)
-        archive_status = (
-            ArchiveStatus.ALL if include_archived else ArchiveStatus.NOT_ARCHIVED
+    ) -> Optional[DecoratedProductionServiceV2APIModel]:
+        # we don't have an api to get a service by name, so we need to list services and filter by name
+        resp = self.list_services(
+            name=name, cloud=cloud, project=project, include_archived=include_archived
         )
+        for result in resp.results:
+            if result.name == name:
+                return result
+        return None
 
-        service: Optional[ServiceModel] = None
-        while True:
-            resp = self._external_api_client.list_services(
-                project_id=project_id,
-                name=name,
-                count=self.LIST_ENDPOINT_COUNT,
-                paging_token=paging_token,
-                archive_status=archive_status,
-            )
-            for result in resp.results:
-                if result.name == name:
-                    service = result
-                    break
+    @handle_api_exceptions
+    def get_service_by_id(
+        self, service_id: str
+    ) -> Optional[DecoratedProductionServiceV2APIModel]:
+        return self._internal_api_client.get_service_api_v2_services_v2_service_id_get(
+            service_id
+        ).result
 
-            paging_token = resp.metadata.next_paging_token
-            if service is not None or paging_token is None:
-                break
+    @handle_api_exceptions
+    def list_services(
+        self,
+        *,
+        name: Optional[str] = None,
+        state_filter: Optional[List[str]] = None,
+        creator_id: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+        include_archived: bool = False,
+        count: Optional[int] = None,
+        paging_token: Optional[str] = None,
+        sort_field: Optional[str] = None,
+        sort_order: Optional[str] = None,
+    ) -> DecoratedlistserviceapimodelListResponse:
+        cloud_id = self.get_cloud_id(cloud_name=cloud) if cloud else None
+        project_id = (
+            self.get_project_id(parent_cloud_id=cloud_id, name=project)
+            if project
+            else None
+        )
 
-        return service
+        return self._internal_api_client.list_services_api_v2_services_v2_get(
+            project_id=project_id,
+            cloud_id=cloud_id,
+            name=name,
+            state_filter=state_filter,
+            creator_id=creator_id,
+            archive_status=ArchiveStatus.ALL
+            if include_archived
+            else ArchiveStatus.NOT_ARCHIVED,
+            count=count if count else self.LIST_ENDPOINT_COUNT,
+            paging_token=paging_token,
+            sort_field=sort_field,
+            sort_order=sort_order,
+        )
 
     @handle_api_exceptions
     def get_project(self, project_id: str) -> Optional[Project]:
@@ -1105,15 +1155,19 @@ class AnyscaleClient(AnyscaleClientInterface):
         return job_runs
 
     @handle_api_exceptions
-    def rollout_service(self, model: ApplyServiceModel) -> ServiceModel:
-        result: ServiceModel = self._external_api_client.rollout_service(model).result
+    def rollout_service(
+        self, model: ApplyProductionServiceV2Model
+    ) -> DecoratedProductionServiceV2APIModel:
+        result = self._internal_api_client.apply_service_api_v2_services_v2_apply_put(
+            model
+        ).result
         return result
 
     @handle_api_exceptions
     def rollback_service(
         self, service_id: str, *, max_surge_percent: Optional[int] = None
-    ) -> ServiceModel:
-        result: ServiceModel = self._external_api_client.rollback_service(
+    ) -> DecoratedProductionServiceV2APIModel:
+        result = self._internal_api_client.rollback_service_api_v2_services_v2_service_id_rollback_post(
             service_id,
             rollback_service_model=RollbackServiceModel(
                 max_surge_percent=max_surge_percent
@@ -1122,17 +1176,23 @@ class AnyscaleClient(AnyscaleClientInterface):
         return result
 
     @handle_api_exceptions
-    def terminate_service(self, service_id: str) -> ServiceModel:
-        result: ServiceModel = self._external_api_client.terminate_service(service_id)
+    def terminate_service(
+        self, service_id: str
+    ) -> DecoratedProductionServiceV2APIModel:
+        result = self._internal_api_client.terminate_service_api_v2_services_v2_service_id_terminate_post(
+            service_id
+        )
         return result
 
     @handle_api_exceptions
-    def archive_service(self, service_id: str) -> ServiceModel:
-        result: ServiceModel = self._external_api_client.archive_service(service_id)
+    def archive_service(self, service_id: str) -> DecoratedProductionServiceV2APIModel:
+        result = self._internal_api_client.archive_service_api_v2_services_v2_service_id_archive_post(
+            service_id
+        )
         return result
 
     @handle_api_exceptions
-    def delete_service(self, service_id: str):
+    def delete_service(self, service_id: str) -> None:
         self._internal_api_client.delete_service_api_v2_services_v2_service_id_delete(
             service_id
         )

anyscale/_private/anyscale_client/common.py

@@ -15,6 +15,8 @@ from anyscale.client.openapi_client.models import (
     CreateResourceQuota,
     CreateUserProjectCollaborator,
     DecoratedComputeTemplate,
+    DecoratedlistserviceapimodelListResponse,
+    DecoratedProductionServiceV2APIModel,
     DeletedPlatformFineTunedModel,
     FineTunedModel,
     InternalProductionJob,
@@ -31,13 +33,12 @@ from anyscale.client.openapi_client.models.decorated_session import DecoratedSes
 from anyscale.client.openapi_client.models.production_job import ProductionJob
 from anyscale.client.openapi_client.models.session_ssh_key import SessionSshKey
 from anyscale.sdk.anyscale_client.models import (
-    ApplyServiceModel,
+    ApplyProductionServiceV2Model,
     Cluster,
     ClusterCompute,
     ClusterEnvironment,
     Job as APIJobRun,
     ProductionServiceV2VersionModel,
-    ServiceModel,
 )
 from anyscale.sdk.anyscale_client.models.cluster_environment_build import (
     ClusterEnvironmentBuild,
@@ -303,13 +304,38 @@ class AnyscaleClientInterface(ABC):
         cloud: Optional[str],
         project: Optional[str],
         include_archived=False,
-    ) -> Optional[ServiceModel]:
+    ) -> Optional[DecoratedProductionServiceV2APIModel]:
         """Get a service by name. Filter by cloud and project.
 
         Returns None if not found.
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_service_by_id(
+        self, service_id: str
+    ) -> Optional[DecoratedProductionServiceV2APIModel]:
+        """Get a service by id."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def list_services(
+        self,
+        *,
+        name: Optional[str],
+        state_filter: Optional[List[str]],
+        creator_id: Optional[str],
+        cloud: Optional[str],
+        project: Optional[str],
+        include_archived: bool,
+        count: Optional[int],
+        paging_token: Optional[str],
+        sort_field: Optional[str],
+        sort_order: Optional[str],
+    ) -> DecoratedlistserviceapimodelListResponse:
+        """List services."""
+        raise NotImplementedError
+
     @abstractmethod
     def get_project(self, project_id: str) -> Optional[Project]:
         """Get a project by id.
@@ -349,7 +375,9 @@ class AnyscaleClientInterface(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def rollout_service(self, model: ApplyServiceModel) -> ServiceModel:
+    def rollout_service(
+        self, model: ApplyProductionServiceV2Model
+    ) -> DecoratedProductionServiceV2APIModel:
         """Deploy or update the service to use the provided config.
 
         Returns the service ID.
@@ -367,17 +395,19 @@ class AnyscaleClientInterface(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def terminate_service(self, service_id: str):
+    def terminate_service(
+        self, service_id: str
+    ) -> DecoratedProductionServiceV2APIModel:
         """Mark the service to be terminated asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
-    def archive_service(self, service_id: str):
+    def archive_service(self, service_id: str) -> DecoratedProductionServiceV2APIModel:
         """Mark the service to be archived asynchronously."""
         raise NotImplementedError
 
     @abstractmethod
-    def delete_service(self, service_id: str):
+    def delete_service(self, service_id: str) -> None:
         """Mark the service to be deleted asynchronously."""
         raise NotImplementedError
 

anyscale/_private/anyscale_client/fake_anyscale_client.py

@@ -26,6 +26,8 @@ from anyscale.client.openapi_client.models import (
     CreateResourceQuota,
     CreateUserProjectCollaborator,
     DecoratedComputeTemplate,
+    DecoratedlistserviceapimodelListResponse,
+    DecoratedProductionServiceV2APIModel,
     DeletedPlatformFineTunedModel,
     ExperimentalWorkspace,
     FineTunedModel,
@@ -33,6 +35,7 @@ from anyscale.client.openapi_client.models import (
     HaJobGoalStates,
     HaJobStates,
     InternalProductionJob,
+    ListResponseMetadata,
     MiniCloud,
     MiniUser,
     OrganizationCollaborator,
@@ -53,7 +56,7 @@ from anyscale.cluster_compute import parse_cluster_compute_name_version
 from anyscale.llm.dataset._private.models import Dataset
 from anyscale.sdk.anyscale_client.configuration import Configuration
 from anyscale.sdk.anyscale_client.models import (
-    ApplyServiceModel,
+    ApplyProductionServiceV2Model,
     Cluster,
     ClusterCompute,
     ClusterComputeConfig,
@@ -63,7 +66,6 @@ from anyscale.sdk.anyscale_client.models import (
     Job as APIJobRun,
     ProductionServiceV2VersionModel,
     ServiceEventCurrentState,
-    ServiceModel,
     ServiceVersionState,
     SessionState,
 )
@@ -143,14 +145,14 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         self._archived_compute_configs: Dict[str, ClusterCompute] = {}
         self._workspace_cluster: Optional[Cluster] = None
         self._workspace_dependency_tracking_enabled: bool = False
-        self._services: Dict[str, ServiceModel] = {}
-        self._archived_services: Dict[str, ServiceModel] = {}
-        self._deleted_services: Dict[str, ServiceModel] = {}
+        self._services: Dict[str, DecoratedProductionServiceV2APIModel] = {}
+        self._archived_services: Dict[str, DecoratedProductionServiceV2APIModel] = {}
+        self._deleted_services: Dict[str, DecoratedProductionServiceV2APIModel] = {}
         self._jobs: Dict[str, ProductionJob] = {}
         self._job_runs: Dict[str, List[APIJobRun]] = defaultdict(list)
         self._project_to_id: Dict[Optional[str] : Dict[Optional[str], str]] = {}
         self._project_collaborators: Dict[str, List[CreateUserProjectCollaborator]] = {}
-        self._rolled_out_model: Optional[ApplyServiceModel] = None
+        self._rolled_out_model: Optional[ApplyProductionServiceV2Model] = None
         self._sent_workspace_notifications: List[WorkspaceNotification] = []
         self._rolled_back_service: Optional[Tuple[str, Optional[int]]] = None
         self._terminated_service: Optional[str] = None
@@ -598,17 +600,17 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
                 cluster_env = self._images[build.cluster_environment_id]
                 return ImageURI.from_cluster_env_build(cluster_env, build)
 
-    def update_service(self, model: ServiceModel):
+    def update_service(self, model: DecoratedProductionServiceV2APIModel):
         self._services[model.id] = model
 
     def get_service(
         self,
         name: str,
         *,
-        cloud: Optional[str],
-        project: Optional[str],
-        include_archived=False,
-    ) -> Optional[ServiceModel]:
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+        include_archived: bool = False,
+    ) -> Optional[DecoratedProductionServiceV2APIModel]:
         cloud_id = self.get_cloud_id(cloud_name=cloud)
         cloud_project_dict = self._project_to_id.get(cloud_id, None)
         project_id = (
@@ -720,10 +722,12 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
             return project_id
 
     @property
-    def rolled_out_model(self) -> Optional[ApplyServiceModel]:
+    def rolled_out_model(self) -> Optional[ApplyProductionServiceV2Model]:
         return self._rolled_out_model
 
-    def rollout_service(self, model: ApplyServiceModel) -> ServiceModel:
+    def rollout_service(
+        self, model: ApplyProductionServiceV2Model
+    ) -> DecoratedProductionServiceV2APIModel:
         self._rolled_out_model = model
         # TODO(mowen): This feels convoluted, is there a better way to pull cloud name and project name from the model?
         project_model = self.get_project(model.project_id)
@@ -738,18 +742,17 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         else:
             service_id = f"service-id-{uuid.uuid4()!s}"
 
-        service = ServiceModel(
+        service = DecoratedProductionServiceV2APIModel(
             id=service_id,
             name=model.name,
-            current_state=ServiceEventCurrentState.RUNNING,
-            cloud_id=cloud_id,
             project_id=model.project_id,
-            base_url="http://fake-service-url",
-            auth_token="fake-auth-token"
-            if model.config.access.use_bearer_token
-            else None,
+            cloud_id=self.get_cloud_id(compute_config_id=model.compute_config_id),
+            current_state=ServiceEventCurrentState.STARTING,
+            base_url=f"http://{model.name}.fake.url",
+            auth_token="fake-auth-token",
             primary_version=ProductionServiceV2VersionModel(
                 id=str(uuid.uuid4()),
+                created_at=datetime.now(),
                 version="primary",
                 current_state=ServiceVersionState.RUNNING,
                 weight=100,
@@ -761,10 +764,13 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
             ),
             local_vars_configuration=OPENAPI_NO_VALIDATION,
         )
-
         self.update_service(service)
         return service
 
+    @property
+    def submitted_job(self) -> Optional[CreateInternalProductionJob]:
+        return self._submitted_job
+
     @property
     def rolled_back_service(self) -> Optional[Tuple[str, Optional[int]]]:
         return self._rolled_back_service
@@ -790,23 +796,19 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
             ].primary_version.current_state = ServiceVersionState.TERMINATED
 
     @property
-    def archived_services(self) -> Dict[str, ServiceModel]:
+    def archived_services(self) -> Dict[str, DecoratedProductionServiceV2APIModel]:
         return self._archived_services
 
     def archive_service(self, service_id: str):
         self._archived_services[service_id] = self._services.pop(service_id)
 
     @property
-    def deleted_services(self) -> Dict[str, ServiceModel]:
+    def deleted_services(self) -> Dict[str, DecoratedProductionServiceV2APIModel]:
         return self._deleted_services
 
     def delete_service(self, service_id: str):
         self._deleted_services[service_id] = self._services.pop(service_id)
 
-    @property
-    def submitted_job(self) -> Optional[CreateInternalProductionJob]:
-        return self._submitted_job
-
     def submit_job(self, model: CreateInternalProductionJob) -> InternalProductionJob:
         self._submitted_job = model
 
@@ -1379,3 +1381,72 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
             raise ValueError(f"Resource Quota with id '{resource_quota_id}' not found.")
 
         resource_quota.is_enabled = is_enabled
+
+    def get_service_by_id(
+        self, service_id: str
+    ) -> Optional[DecoratedProductionServiceV2APIModel]:
+        if service_id in self._services:
+            return self._services[service_id]
+        if service_id in self._archived_services:
+            return self._archived_services[service_id]
+        if service_id in self._deleted_services:
+            return self._deleted_services[service_id]
+        return None
+
+    def list_services(
+        self,
+        *,
+        name: Optional[str] = None,
+        state_filter: Optional[List[str]] = None,
+        creator_id: Optional[str] = None,  # noqa: ARG002
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
+        include_archived: bool = False,
+        count: Optional[int] = None,
+        paging_token: Optional[str] = None,  # noqa: ARG002
+        sort_field: Optional[str] = None,  # noqa: ARG002
+        sort_order: Optional[str] = None,  # noqa: ARG002
+    ) -> DecoratedlistserviceapimodelListResponse:
+        target_services = list(self._services.values())
+        if include_archived:
+            target_services.extend(list(self._archived_services.values()))
+
+        target_cloud_id = self.get_cloud_id(cloud_name=cloud) if cloud else None
+        target_project_id = (
+            self.get_project_id(parent_cloud_id=target_cloud_id, name=project)
+            if project
+            else None
+        )
+
+        filtered_results = []
+        for svc in target_services:
+            if name is not None and svc.name != name:
+                continue
+            # Ensure state comparison works whether svc.current_state is Enum or str
+            current_state_str = (
+                svc.current_state.value
+                if hasattr(svc.current_state, "value")
+                else svc.current_state
+            )
+            if state_filter is not None and current_state_str not in state_filter:
+                continue
+            if target_project_id is not None and svc.project_id != target_project_id:
+                continue
+            if target_cloud_id is not None and svc.cloud_id != target_cloud_id:
+                continue
+
+            filtered_results.append(svc)
+
+        if count is None:
+            count = len(filtered_results)
+        final_results = filtered_results[:count]
+
+        response = DecoratedlistserviceapimodelListResponse(
+            results=final_results,
+            metadata=ListResponseMetadata(
+                total=len(final_results),
+                next_paging_token=None,  # Fake doesn't support paging
+            ),
+            local_vars_configuration=OPENAPI_NO_VALIDATION,
+        )
+        return response

anyscale/_private/models/model_base.py

@@ -1,9 +1,13 @@
+import asyncio
+from collections import deque
 from dataclasses import asdict, fields
 from enum import Enum, EnumMeta
 import inspect
 from typing import (
     Any,
+    Awaitable,
     Callable,
+    Deque,
     Dict,
     Generic,
     Iterable,
@@ -252,3 +256,94 @@ class ListResponse(List[TModelBase]):
                 return
             if index >= len(self) and self.has_more:
                 self._fetch_next_page()
+
+
+RT = TypeVar("RT")
+
+
+class ResultIterator(Generic[RT]):
+    """
+    Lazily fetch and parse pages from a paged-list API that returns
+    Pydantic models with `.results` and `.metadata.next_paging_token`.
+    """
+
+    def __init__(
+        self,
+        *,
+        page_token: Optional[str],
+        max_items: Optional[int],
+        fetch_page: Callable[[Optional[str]], Any],
+        parse_fn: Optional[Callable[[Any], RT]] = None,
+        async_parse_fn: Optional[Callable[[Any], Awaitable[RT]]] = None,
+    ):
+        if parse_fn and async_parse_fn:
+            raise ValueError("Only one of parse_fn or async_parse_fn may be provided")
+
+        self._token = page_token
+        self._max = max_items
+        self._fetch = fetch_page
+        self._parse = parse_fn
+        self._aparse = async_parse_fn
+        self._buffer: Deque[RT] = deque()
+        self._count = 0
+        self._finished = False
+
+    def __iter__(self) -> Iterator[RT]:
+        while True:
+            # 1) Drain the buffer
+            while self._buffer:
+                if self._max is not None and self._count >= self._max:
+                    return
+                self._count += 1
+                yield self._buffer.popleft()
+
+            # 2) Done?
+            if self._finished or (self._max is not None and self._count >= self._max):
+                return
+
+            # 3) Fetch the next page (Pydantic model)
+            page = self._fetch(self._token)
+            raw_results = page.results
+            self._token = page.metadata.next_paging_token
+
+            # 4) No more data?
+            if not raw_results:
+                self._finished = True
+                return
+
+            # 5) Parse—sync or async
+            if self._aparse:
+                processed = asyncio.run(
+                    ResultIterator._process_items_async(raw_results, self._aparse)
+                )
+                self._buffer.extend(processed)
+
+            elif self._parse:
+                try:
+                    for raw in raw_results:
+                        self._buffer.append(self._parse(raw))
+                except Exception as e:  # noqa: BLE001
+                    raise RuntimeError(f"sync parse error: {e}") from e
+
+            else:
+                # No parser: assume items are already RT
+                self._buffer.extend(raw_results)  # type: ignore
+
+            # 6) If no next token, finish on next loop
+            if self._token is None:
+                self._finished = True
+
+    @staticmethod
+    async def _process_items_async(
+        items: List[Any], parser: Callable[[Any], Awaitable[RT]],
+    ) -> List[RT]:
+        if not items:
+            return []
+        tasks = [parser(item) for item in items]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        processed: List[RT] = []
+        for idx, res in enumerate(results):
+            if isinstance(res, Exception):
+                raise RuntimeError(f"async parse failed on item {idx}: {res}") from res
+            processed.append(res)
+        return processed

anyscale/_private/workload/workload_sdk.py

@@ -328,4 +328,6 @@ class WorkloadSDK(BaseSDK):
         if not compute_config.anonymous:
             return compute_config_name
 
-        return self._compute_config_sdk.get_compute_config(id=compute_config_id).config
+        return self._compute_config_sdk._convert_api_model_to_compute_config_version(  # noqa: SLF001
+            compute_config
+        ).config