anyscale 0.24.6__tar.gz → 0.24.7__tar.gz

{anyscale-0.24.6 → anyscale-0.24.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anyscale
-Version: 0.24.6
+Version: 0.24.7
 Summary: Command Line Interface for Anyscale
 Author: Anyscale Inc.
 License: AS License

{anyscale-0.24.6 → anyscale-0.24.7}/anyscale/__init__.py

@@ -49,5 +49,3 @@ for attr, _ in inspect.getmembers(ClientBuilder, inspect.isfunction):
 __version__ = version.__version__
 
 ANYSCALE_ENV = os.environ.copy()
-
-import anyscale.job

{anyscale-0.24.6 → anyscale-0.24.7}/anyscale/_private/anyscale_client/anyscale_client.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import pathlib
 import re
 import time
@@ -23,7 +24,9 @@ from anyscale.client.openapi_client.models import (
     ComputeTemplateConfig,
     ComputeTemplateQuery,
     CreateComputeTemplate,
+    CreateInternalProductionJob,
     DecoratedComputeTemplate,
+    InternalProductionJob,
 )
 from anyscale.cluster_compute import parse_cluster_compute_name_version
 from anyscale.sdk.anyscale_client.api.default_api import DefaultApi as ExternalApi
@@ -66,6 +69,8 @@ from anyscale.utils.workspace_notification import (
 block_logger = BlockLogger()
 logger = logging.getLogger(__name__)
 
+WORKSPACE_ID_ENV_VAR = "ANYSCALE_EXPERIMENTAL_WORKSPACE_ID"
+
 
 class AnyscaleClient(AnyscaleClientInterface):
     # Number of entries to fetch per request for list endpoints.
@@ -93,11 +98,17 @@ class AnyscaleClient(AnyscaleClientInterface):
         self._cloud_id_cache: Dict[Optional[str], str] = {}
         self._current_workspace_cluster: Optional[Cluster] = None
 
+    def get_job_ui_url(self, job_id: str) -> str:
+        return get_endpoint(f"/jobs/{job_id}")
+
     def get_service_ui_url(self, service_id: str) -> str:
         return get_endpoint(f"/services/{service_id}")
 
+    def get_current_workspace_id(self) -> Optional[str]:
+        return os.environ.get(WORKSPACE_ID_ENV_VAR, None)
+
     def inside_workspace(self) -> bool:
-        return self.get_current_workspace_cluster() is not None
+        return self.get_current_workspace_id() is not None
 
     def get_workspace_requirements_path(self) -> Optional[str]:
         if (
@@ -214,8 +225,11 @@ class AnyscaleClient(AnyscaleClientInterface):
 
         # If the compute config name is not provided, we pick an appropriate default.
         #
-        #   - If running in a workspace, we use the workspace's compute config, with
-        #     a minor transformation if auto_select_worker_config is applied.
+        #   - If running in a workspace:
+        #       * If auto_select_worker_config enabled: we switch over to a standardized
+        #         default compute config (copying over any cluster-level attributes, e.g.
+        #         max-gpus).
+        #       * Otherwise, we use the workspace's compute config.
         #
         #   - Otherwise, we use the default compute config provided by the API.
 
@@ -226,10 +240,10 @@ class AnyscaleClient(AnyscaleClientInterface):
             )
             workspace_config: ClusterComputeConfig = workspace_compute_config.config
             if workspace_config.auto_select_worker_config:
-                workspace_config = self._apply_standardized_head_node_type(
+                standard_template = self._build_standard_compute_template_from_existing_auto_config(
                     workspace_config
                 )
-                return self.create_anonymous_compute_config(workspace_config)
+                return self.create_anonymous_compute_config(standard_template)
             else:
                 return workspace_cluster.cluster_compute_id
 
@@ -237,29 +251,39 @@ class AnyscaleClient(AnyscaleClientInterface):
         # is the non-deprecated API to use for compute configs.
         return self._external_api_client.get_default_cluster_compute().result.id
 
-    def _apply_standardized_head_node_type(
+    def _build_standard_compute_template_from_existing_auto_config(
         self, compute_config: ClusterComputeConfig
-    ) -> ClusterComputeConfig:
+    ) -> ComputeTemplateConfig:
         """
-        Apply the following transformations to the provided compute config:
+        Build a standard compute template config from an existing compute config.
 
-        1. Standardize the head node instance type.
+        1. Pull the default compute template config.
         2. Disable scheduling on the head node.
+        3. Enable auto_select_worker_config.
+        4. Copy any cluster-level flags from the provided compute config to the template.
         """
-        # Retrieve the default cluster compute config.
-        default_compute_config: DecoratedComputeTemplate = self._external_api_client.get_default_cluster_compute().result.config
+        # Retrieve the default cluster compute config for the cloud.
+        default_compute_template: DecoratedComputeTemplate = self._external_api_client.get_default_cluster_compute(
+            cloud_id=compute_config.cloud_id,
+        ).result.config
 
-        # Standardize the head node instance type.
-        compute_config.head_node_type.instance_type = (
-            default_compute_config.head_node_type.instance_type
-        )
+        # Disable head node scheduling.
+        if default_compute_template.head_node_type.resources is None:
+            default_compute_template.head_node_type.resources = {}
+        default_compute_template.head_node_type.resources["CPU"] = 0
 
-        # Disable scheduling on the head node.
-        if compute_config.head_node_type.resources is None:
-            compute_config.head_node_type.resources = {}
-        compute_config.head_node_type.resources["CPU"] = 0
+        # Ensure auto_select_worker_config is enabled.
+        default_compute_template.auto_select_worker_config = True
 
-        return compute_config
+        # Copy flags set at a cluster level over to the workspace.
+        #
+        # NOTE (shomilj): If there are more attributes we want to
+        # persist from the provided compute config --> the compute
+        # config used for deploying the service, we should copy them
+        # over here.
+        default_compute_template.flags = compute_config.flags
+
+        return default_compute_template
 
     def get_cluster_env_build_image_uri(
         self, cluster_env_build_id: str
@@ -322,9 +346,7 @@ class AnyscaleClient(AnyscaleClientInterface):
         Raise a TimeoutError if the build does not complete within the timeout.
         """
         elapsed_secs = 0
-        block_logger.info(
-            f"Waiting for cluster environment build ({build_id}) to complete."
-        )
+        block_logger.info(f"Waiting for image build ({build_id}) to complete.")
         while elapsed_secs < timeout_secs:
             build = self._external_api_client.get_cluster_environment_build(
                 build_id
@@ -472,6 +494,12 @@ class AnyscaleClient(AnyscaleClientInterface):
         result: ServiceModel = self._external_api_client.terminate_service(service_id)
         return result
 
+    def submit_job(self, model: CreateInternalProductionJob) -> InternalProductionJob:
+        job: InternalProductionJob = self._internal_api_client.create_job_api_v2_decorated_ha_jobs_create_post(
+            model,
+        ).result
+        return job
+
     def upload_local_dir_to_cloud_storage(
         self, local_dir: str, *, cloud_id: str, excludes: Optional[List[str]] = None
     ) -> str:

{anyscale-0.24.6 → anyscale-0.24.7}/anyscale/_private/anyscale_client/common.py

@@ -3,7 +3,9 @@ from typing import List, Optional
 
 from anyscale.client.openapi_client.models import (
     ComputeTemplateConfig,
+    CreateInternalProductionJob,
     DecoratedComputeTemplate,
+    InternalProductionJob,
 )
 from anyscale.sdk.anyscale_client.models import (
     ApplyServiceModel,
@@ -26,11 +28,21 @@ WORKSPACE_CLUSTER_NAME_PREFIX = "workspace-cluster-"
 
 
 class AnyscaleClientInterface(ABC):
+    @abstractmethod
+    def get_job_ui_url(self, job_id: str) -> str:
+        """Get a URL to the webpage for a job."""
+        raise NotImplementedError
+
     @abstractmethod
     def get_service_ui_url(self, service_id: str) -> str:
         """Get a URL to the webpage for a service."""
         raise NotImplementedError
 
+    @abstractmethod
+    def get_current_workspace_id(self) -> Optional[str]:
+        """Returns the ID of the workspace this is running in (or `None`)."""
+        raise NotImplementedError
+
     @abstractmethod
     def inside_workspace(self) -> bool:
         """Returns true if this code is running inside a workspace."""
@@ -186,6 +198,11 @@ class AnyscaleClientInterface(ABC):
         """Mark the service to be terminated asynchronously."""
         raise NotImplementedError
 
+    @abstractmethod
+    def submit_job(self, model: CreateInternalProductionJob) -> InternalProductionJob:
+        """Submit the job to run."""
+        raise NotImplementedError
+
     @abstractmethod
     def upload_local_dir_to_cloud_storage(
         self, local_dir: str, *, cloud_id: str, excludes: Optional[List[str]] = None

{anyscale-0.24.6 → anyscale-0.24.7}/anyscale/_private/anyscale_client/fake_anyscale_client.py

@@ -9,7 +9,12 @@ from anyscale._private.anyscale_client.common import (
 from anyscale.cli_logger import BlockLogger
 from anyscale.client.openapi_client.models import (
     ComputeTemplateConfig,
+    CreateInternalProductionJob,
     DecoratedComputeTemplate,
+    HaJobGoalStates,
+    HaJobStates,
+    InternalProductionJob,
+    ProductionJobStateTransition,
 )
 from anyscale.sdk.anyscale_client.configuration import Configuration
 from anyscale.sdk.anyscale_client.models import (
@@ -37,6 +42,7 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     DEFAULT_CLUSTER_COMPUTE_ID = "fake-default-cluster-compute-id"
     DEFAULT_CLUSTER_ENV_BUILD_ID = "fake-default-cluster-env-build-id"
 
+    WORKSPACE_ID = "fake-workspace-id"
     WORKSPACE_CLOUD_ID = "fake-workspace-cloud-id"
     WORKSPACE_CLUSTER_ID = "fake-workspace-cluster-id"
     WORKSPACE_PROJECT_ID = "fake-workspace-project-id"
@@ -57,6 +63,12 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         self._sent_workspace_notifications: List[WorkspaceNotification] = []
         self._rolled_back_service: Optional[Tuple[str, Optional[int]]] = None
         self._terminated_service: Optional[str] = None
+        self._requirements_path: Optional[str] = None
+        self._upload_uri_mapping: Dict[str, str] = {}
+        self._submitted_job: Optional[CreateInternalProductionJob] = None
+
+    def get_job_ui_url(self, job_id: str) -> str:
+        return f"{self.BASE_UI_URL}/jobs/{job_id}"
 
     def get_service_ui_url(self, service_id: str) -> str:
         return f"{self.BASE_UI_URL}/services/{service_id}"
@@ -83,6 +95,13 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         else:
             self._workspace_cluster = None
 
+    def get_current_workspace_id(self) -> Optional[str]:
+        return (
+            self.WORKSPACE_ID
+            if self.get_current_workspace_cluster() is not None
+            else None
+        )
+
     def inside_workspace(self) -> bool:
         return self.get_current_workspace_cluster() is not None
 
@@ -250,6 +269,25 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     def terminate_service(self, service_id: str):
         self._terminated_service = service_id
 
+    @property
+    def submitted_job(self) -> Optional[CreateInternalProductionJob]:
+        return self._submitted_job
+
+    def submit_job(self, model: CreateInternalProductionJob) -> InternalProductionJob:
+        self._submitted_job = model
+
+        return InternalProductionJob(
+            id=f"job-{str(uuid.uuid4())}",
+            name=model.name,
+            config=model.config,
+            state=ProductionJobStateTransition(
+                current_state=HaJobStates.PENDING,
+                goal_state=HaJobGoalStates.SUCCESS,
+                local_vars_configuration=OPENAPI_NO_VALIDATION,
+            ),
+            local_vars_configuration=OPENAPI_NO_VALIDATION,
+        )
+
     def upload_local_dir_to_cloud_storage(
         self,
         local_dir: str,  # noqa: ARG002
@@ -257,5 +295,12 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         cloud_id: str,
         excludes: Optional[List[str]] = None,  # noqa: ARG002
     ) -> str:
+        # Ensure that URIs are consistent for the same passed directory.
+        if local_dir in self._upload_uri_mapping:
+            uri = self._upload_uri_mapping[local_dir]
+        else:
+            uri = str(uuid.uuid4())
+            self._upload_uri_mapping[local_dir] = uri
+
         bucket = self.CLOUD_BUCKET.format(cloud_id=cloud_id)
-        return f"{bucket}/fake_pkg_{uuid.uuid4()}.zip"
+        return f"{bucket}/fake_pkg_{uri}.zip"

anyscale-0.24.7/anyscale/_private/models/__init__.py

@@ -0,0 +1,2 @@
+from anyscale._private.models.model_base import ModelBase
+from anyscale._private.models.workload_config import WorkloadConfig

anyscale-0.24.7/anyscale/_private/models/workload_config.py

@@ -0,0 +1,85 @@
+from dataclasses import dataclass, field
+import re
+from typing import Dict, List, Optional, Union
+
+from anyscale._private.models import ModelBase
+
+
+IMAGE_URI_PATTERN = "[registry_host/]user_name/repository[:tag][@digest]"
+IMAGE_URI_PATTERN_RE = re.compile(
+    r"^"
+    # Optional registry host: hostname with optional port
+    r"((?P<host>[a-zA-Z0-9.-]+)(?::(?P<port>[0-9]+))?/)?"
+    # Repository name: user_name/repository
+    r"(?P<repository>[a-zA-Z0-9-_]+/([a-zA-Z0-9-/_])+)"
+    # Optional Tag: version or string after ':'
+    r"(:(?P<tag>[a-zA-Z0-9_.-]+))?"
+    # Optional Digest: string after '@'
+    # Note that when both tag and digest are provided, the tag is ignored.
+    r"(@(?P<digest>[a-zA-Z0-9]+))?"
+    r"$"
+)
+
+
+@dataclass(frozen=True)
+class WorkloadConfig(ModelBase):
+    name: Optional[str] = field(default=None)
+
+    def _validate_name(self, name: Optional[str]):
+        if name is not None and not isinstance(name, str):
+            raise TypeError("'name' must be a string.")
+
+    image_uri: Optional[str] = field(default=None)
+
+    def _validate_image_uri(self, image_uri: Optional[str]):
+        if image_uri is None:
+            return
+
+        if not isinstance(image_uri, str):
+            raise TypeError("'image_uri' must be a string.")
+
+        matches = IMAGE_URI_PATTERN_RE.match(image_uri)
+        if not matches:
+            raise ValueError(
+                f"Invalid image URI: '{image_uri}'. Must be in the format: '{IMAGE_URI_PATTERN}'."
+            )
+
+    containerfile: Optional[str] = field(default=None, repr=False)
+
+    def _validate_containerfile(self, containerfile: Optional[str]):
+        if containerfile is not None and not isinstance(containerfile, str):
+            raise TypeError("'containerfile' must be a string.")
+
+    compute_config: Optional[Union[Dict, str]] = field(default=None)
+
+    def _validate_compute_config(self, compute_config: Optional[Union[Dict, str]]):
+        if compute_config is not None and not isinstance(compute_config, (str, dict)):
+            raise TypeError("'compute_config' must be a string or dictionary.")
+
+    working_dir: Optional[str] = field(default=None, repr=False)
+
+    def _validate_working_dir(self, working_dir: Optional[str]):
+        if working_dir is not None and not isinstance(working_dir, str):
+            raise TypeError("'working_dir' must be a string.")
+
+    excludes: Optional[List[str]] = field(default=None, repr=False)
+
+    def _validate_excludes(self, excludes: Optional[List[str]]):
+        if excludes is not None and (
+            not isinstance(excludes, list)
+            or not all(isinstance(e, str) for e in excludes)
+        ):
+            raise TypeError("'excludes' must be a list of strings.")
+
+    requirements: Optional[Union[str, List[str]]] = field(default=None, repr=False)
+
+    def _validate_requirements(self, requirements: Optional[Union[str, List[str]]]):
+        if requirements is None or isinstance(requirements, str):
+            return
+
+        if not isinstance(requirements, list) or not all(
+            isinstance(r, str) for r in requirements
+        ):
+            raise TypeError(
+                "'requirements' must be a string (file path) or list of strings."
+            )

anyscale-0.24.7/anyscale/_private/sdk/__init__.py

@@ -0,0 +1,25 @@
+from functools import wraps
+from typing import Any, Callable, Dict, List, Optional, Type, Union
+
+
+_LAZY_SDK_SINGLETONS: Dict[str, Callable] = {}
+
+
+def inject_sdk_singleton(key: str, sdk_cls: Type) -> Callable[[Callable], Callable]:
+    """Decorator to automatically inject an `_sdk` arg into the wrapped function.
+
+    The arguments to this class are a unique key for the singleton and its type
+    (the constructor will be called with no arguments).
+    """
+
+    def _inject_typed_sdk_singleton(f: Callable) -> Callable:
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            if key not in _LAZY_SDK_SINGLETONS:
+                _LAZY_SDK_SINGLETONS[key] = sdk_cls()
+
+            return f(*args, _sdk=_LAZY_SDK_SINGLETONS[key], **kwargs)
+
+        return wrapper
+
+    return _inject_typed_sdk_singleton

anyscale-0.24.7/anyscale/_private/sdk/workload_sdk.py

@@ -0,0 +1,271 @@
+import copy
+import pathlib
+from typing import Any, Dict, List, Optional, Union
+
+from anyscale._private.anyscale_client import (
+    AnyscaleClient,
+    AnyscaleClientInterface,
+    WORKSPACE_CLUSTER_NAME_PREFIX,
+)
+from anyscale.cli_logger import BlockLogger
+from anyscale.client.openapi_client.models import (
+    ComputeTemplateConfig,
+    DecoratedComputeTemplateConfig,
+)
+from anyscale.utils.runtime_env import is_dir_remote_uri, parse_requirements_file
+
+
+class WorkloadSDK:
+    """Shared parent class for job and service SDKs."""
+
+    def __init__(
+        self,
+        *,
+        logger: Optional[BlockLogger] = None,
+        client: Optional[AnyscaleClientInterface] = None,
+    ):
+        self._logger = logger or BlockLogger()
+        self._client = client or AnyscaleClient()
+
+    @property
+    def logger(self) -> BlockLogger:
+        return self._logger
+
+    @property
+    def client(self) -> AnyscaleClientInterface:
+        return self._client
+
+    def override_and_load_requirements_files(
+        self,
+        runtime_envs: List[Dict[str, Any]],
+        *,
+        requirements_override: Union[None, str, List[str]],
+        autopopulate_in_workspace: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """Replaces 'pip' fields in runtime_envs with their parsed file contents.
+
+        The precedence for overrides is: explicit overrides passed in > fields in the existing
+        runtime_envs > workspace defaults (if `autopopulate_in_workspace == True`).
+        """
+        new_runtime_envs = copy.deepcopy(runtime_envs)
+
+        local_path_to_parsed_requirements: Dict[str, List[str]] = {}
+
+        def _load_requirements_file_memoized(
+            target: Union[str, List[str]]
+        ) -> List[str]:
+            if isinstance(target, list):
+                return target
+            elif target in local_path_to_parsed_requirements:
+                return local_path_to_parsed_requirements[target]
+            elif isinstance(target, str):
+                parsed_requirements = parse_requirements_file(target)
+                if parsed_requirements is None:
+                    raise FileNotFoundError(
+                        f"Requirements file {target} does not exist."
+                    )
+                local_path_to_parsed_requirements[target] = parsed_requirements
+                return parsed_requirements
+            else:
+                raise TypeError("pip field in runtime_env must be a list or string.")
+
+            return parsed_requirements
+
+        for runtime_env in new_runtime_envs:
+            if requirements_override is not None:
+                # Explicitly-specified override from the user.
+                runtime_env["pip"] = requirements_override
+            elif (
+                autopopulate_in_workspace
+                and self._client.inside_workspace()
+                and "pip" not in runtime_env
+                and "conda" not in runtime_env
+            ):
+                # If no "pip" or "conda" field was specified, try filling it in from
+                # the workspace-tracked requirements file.
+                workspace_requirements_path = (
+                    self._client.get_workspace_requirements_path()
+                )
+                if workspace_requirements_path is not None:
+                    self.logger.info("Including workspace-managed pip dependencies.")
+                    runtime_env["pip"] = workspace_requirements_path
+
+            if runtime_env.get("pip", None) is not None:
+                # Load requirements from the file if necessary.
+                runtime_env["pip"] = _load_requirements_file_memoized(
+                    runtime_env["pip"]
+                )
+
+        return new_runtime_envs
+
+    def override_and_upload_local_dirs(
+        self,
+        runtime_envs: List[Dict[str, Any]],
+        *,
+        working_dir_override: Optional[str],
+        excludes_override: Optional[List[str]],
+        cloud_id: Optional[str] = None,
+        autopopulate_in_workspace: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """Returns modified runtime_envs with all local dirs converted to remote URIs.
+
+        The precedence for overrides is: explicit overrides passed in > fields in the existing
+        runtime_envs > workspace defaults (if `autopopulate_in_workspace == True`).
+
+        Each unique local directory across these fields will be uploaded once to cloud storage,
+        then all occurrences of it in the config will be replaced with the corresponding remote URI.
+        """
+        new_runtime_envs = copy.deepcopy(runtime_envs)
+
+        local_path_to_uri: Dict[str, str] = {}
+
+        def _upload_dir_memoized(target: str, *, excludes: Optional[List[str]]) -> str:
+            if is_dir_remote_uri(target):
+                return target
+            if target in local_path_to_uri:
+                return local_path_to_uri[target]
+
+            self.logger.info(f"Uploading local dir '{target}' to cloud storage.")
+            uri = self._client.upload_local_dir_to_cloud_storage(
+                target, cloud_id=cloud_id, excludes=excludes,
+            )
+            local_path_to_uri[target] = uri
+            return uri
+
+        for runtime_env in new_runtime_envs:
+            # Extend, don't overwrite, excludes if it's provided.
+            if excludes_override is not None:
+                existing_excludes = runtime_env.get("excludes", None) or []
+                runtime_env["excludes"] = existing_excludes + excludes_override
+
+            final_excludes = runtime_env.get("excludes", [])
+
+            new_working_dir = None
+            if working_dir_override is not None:
+                new_working_dir = working_dir_override
+            elif "working_dir" in runtime_env:
+                new_working_dir = runtime_env["working_dir"]
+            elif autopopulate_in_workspace and self._client.inside_workspace():
+                new_working_dir = "."
+
+            if new_working_dir is not None:
+                runtime_env["working_dir"] = _upload_dir_memoized(
+                    new_working_dir, excludes=final_excludes
+                )
+
+            py_modules = runtime_env.get("py_modules", None)
+            if py_modules is not None:
+                runtime_env["py_modules"] = [
+                    _upload_dir_memoized(py_module, excludes=final_excludes)
+                    for py_module in py_modules
+                ]
+
+        return new_runtime_envs
+
+    def resolve_compute_config_to_id(
+        self, compute_config: Optional[Union[str, Dict]]
+    ) -> str:
+        """Resolve the passed compute config to an ID that can be passed to the backend.
+
+        Accepts either:
+            - A string of the form: '<name>[:<version>]'.
+            - A dictionary from which an anonymous compute config will be built.
+        """
+        if compute_config is None:
+            compute_config_id = self._client.get_compute_config_id()
+            assert compute_config_id is not None
+        elif isinstance(compute_config, str):
+            compute_config_id = self._client.get_compute_config_id(
+                compute_config_name=compute_config,
+            )
+            if compute_config_id is None:
+                raise ValueError(
+                    f"The compute config '{compute_config}' does not exist."
+                )
+        else:
+            try:
+                compute_config_template = ComputeTemplateConfig(**compute_config)
+            except (ValueError, TypeError) as e:
+                raise RuntimeError(f"Invalid compute config: {e}.")
+
+            compute_config_id = self._client.create_anonymous_compute_config(
+                compute_config_template
+            )
+
+        return compute_config_id
+
+    def get_current_workspace_name(self) -> Optional[str]:
+        """Get the name of the curernt workspace if running inside one."""
+        if not self._client.inside_workspace():
+            return None
+
+        name = self._client.get_current_workspace_cluster().name
+        # Defensively default to the workspace cluster name as-is if it doesn't
+        # start with the expected prefix.
+        if name.startswith(WORKSPACE_CLUSTER_NAME_PREFIX):
+            name = name[len(WORKSPACE_CLUSTER_NAME_PREFIX) :]
+
+        return name
+
+    def get_containerfile_contents(self, path: str) -> str:
+        """Get the full content of the containerfile as a string."""
+        containerfile_path = pathlib.Path(path)
+        if not containerfile_path.exists():
+            raise FileNotFoundError(
+                f"Containerfile '{containerfile_path}' does not exist."
+            )
+        if not containerfile_path.is_file():
+            raise ValueError(f"Containerfile '{containerfile_path}' must be a file.")
+
+        return containerfile_path.read_text()
+
+    def _strip_none_values_from_dict(self, d: Dict) -> Dict:
+        """Return a copy of the dictionary without any keys whose values are None.
+
+        Recursively calls into any dictionary values.
+        """
+        result = {}
+        for k, v in d.items():
+            if isinstance(v, dict):
+                result[k] = self._strip_none_values_from_dict(v)
+            elif v is not None:
+                result[k] = v
+
+        return result
+
+    def get_user_facing_compute_config(
+        self, compute_config_id: str,
+    ) -> Union[str, Dict]:
+        """Get the compute config in a format to be displayed in a user-facing status.
+
+        If the compute config refers to an anonymous compute config, its config
+        dictionary will be returned. Else the name of the compute config will be
+        returned in the form: '<name>:<version>'.
+        """
+        compute_config = self._client.get_compute_config(compute_config_id)
+        if compute_config is None:
+            raise RuntimeError(
+                f"Failed to get compute config for ID {compute_config_id}."
+            )
+
+        if not compute_config.anonymous:
+            compute_config_name = compute_config.name
+            if compute_config.version is not None:
+                compute_config_name += f":{compute_config.version}"
+            return compute_config_name
+
+        config: DecoratedComputeTemplateConfig = compute_config.config
+        config_dict = {
+            # Strip some internal fields that we don't want to expose to the user.
+            # TODO(edoakes): we should improve the compute config model and avoid this.
+            k: v
+            for k, v in config.to_dict().items()
+            if k
+            not in {
+                "cloud",
+                "cloud_id",
+                "maximum_uptime_minutes",
+                "idle_termination_minutes",
+            }
+        }
+        return self._strip_none_values_from_dict(config_dict)