anyscale 0.24.10__tar.gz → 0.24.12__tar.gz

{anyscale-0.24.10 → anyscale-0.24.12}/PKG-INFO

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

{anyscale-0.24.10 → anyscale-0.24.12}/anyscale/_private/anyscale_client/anyscale_client.py

@@ -18,9 +18,11 @@ from anyscale.cli_logger import BlockLogger
 from anyscale.client.openapi_client.api.default_api import DefaultApi as InternalApi
 from anyscale.client.openapi_client.models import (
     ArchiveStatus,
+    Cloud,
     CloudDataBucketFileType,
     CloudDataBucketPresignedUploadInfo,
     CloudDataBucketPresignedUploadRequest,
+    CloudNameOptions,
     ComputeTemplateConfig,
     ComputeTemplateQuery,
     CreateComputeTemplate,
@@ -28,11 +30,11 @@ from anyscale.client.openapi_client.models import (
     DecoratedComputeTemplate,
     InternalProductionJob,
 )
+from anyscale.client.openapi_client.rest import ApiException as InternalApiException
 from anyscale.cluster_compute import parse_cluster_compute_name_version
 from anyscale.sdk.anyscale_client.api.default_api import DefaultApi as ExternalApi
 from anyscale.sdk.anyscale_client.models import (
     ApplyServiceModel,
-    Cloud,
     Cluster,
     ClusterCompute,
     ClusterComputeConfig,
@@ -49,7 +51,8 @@ from anyscale.sdk.anyscale_client.models.create_cluster_environment import (
 from anyscale.sdk.anyscale_client.models.create_cluster_environment_build import (
     CreateClusterEnvironmentBuild,
 )
-from anyscale.sdk.anyscale_client.rest import ApiException
+from anyscale.sdk.anyscale_client.rest import ApiException as ExternalApiException
+from anyscale.shared_anyscale_utils.conf import ANYSCALE_HOST
 from anyscale.util import (
     get_cluster_model_for_current_workspace,
     get_endpoint,
@@ -70,6 +73,8 @@ WORKSPACE_ID_ENV_VAR = "ANYSCALE_EXPERIMENTAL_WORKSPACE_ID"
 OVERWRITE_EXISTING_CLOUD_STORAGE_FILES = (
     os.environ.get("ANYSCALE_OVERWRITE_EXISTING_CLOUD_STORAGE_FILES", "0") == "1"
 )
+
+# internal_logger is used for logging internal errors or debug messages that we do not expect users to see.
 internal_logger = logging.getLogger(__name__)
 
 
@@ -84,6 +89,7 @@ class AnyscaleClient(AnyscaleClientInterface):
         sleep: Optional[Callable[[float], None]] = None,
         workspace_requirements_file_path: str = WORKSPACE_REQUIREMENTS_FILE_PATH,
         logger: Optional[BlockLogger] = None,
+        host: Optional[str] = None,
     ):
         if api_clients is None:
             auth_block: AuthenticationBlock = get_auth_api_client(
@@ -100,19 +106,26 @@ class AnyscaleClient(AnyscaleClientInterface):
         self._cloud_id_cache: Dict[Optional[str], str] = {}
         self._current_workspace_cluster: Optional[Cluster] = None
         self._logger = logger or BlockLogger()
+        self._host = host or ANYSCALE_HOST
+
+    @property
+    def host(self) -> str:
+        return self._host
 
     @property
     def logger(self) -> BlockLogger:
         return self._logger
 
     def get_job_ui_url(self, job_id: str) -> str:
-        return get_endpoint(f"/jobs/{job_id}")
+        return get_endpoint(f"/jobs/{job_id}", host=self.host)
 
     def get_service_ui_url(self, service_id: str) -> str:
-        return get_endpoint(f"/services/{service_id}")
+        return get_endpoint(f"/services/{service_id}", host=self.host)
 
     def get_build_ui_url(self, cluster_env_id, build_id: str) -> str:
-        return get_endpoint(f"/container-images/{cluster_env_id}/versions/{build_id}")
+        return get_endpoint(
+            f"/container-images/{cluster_env_id}/versions/{build_id}", host=self.host
+        )
 
     def get_current_workspace_id(self) -> Optional[str]:
         return os.environ.get(WORKSPACE_ID_ENV_VAR, None)
@@ -161,11 +174,24 @@ class AnyscaleClient(AnyscaleClientInterface):
         cluster_compute_config: ClusterComputeConfig = cluster_compute.config
         return cluster_compute_config.cloud_id
 
+    def _get_cloud_id_by_name(self, cloud_name: str) -> Optional[str]:
+        try:
+            return self._internal_api_client.find_cloud_by_name_api_v2_clouds_find_by_name_post(
+                CloudNameOptions(name=cloud_name),
+            ).result.id
+        except InternalApiException as e:
+            if e.status == 404:
+                return None
+
+            raise e from None
+
     def get_cloud_id(
         self, cloud_name: Optional[str] = None, compute_config_id: Optional[str] = None
-    ) -> Optional[str]:
-        if cloud_name is not None:
-            raise NotImplementedError("Only default cloud is currently implemented.")
+    ) -> str:
+        if cloud_name is not None and compute_config_id is not None:
+            raise ValueError(
+                "Only one of cloud_name or compute_config_id should be provided."
+            )
 
         if compute_config_id is not None:
             return self._get_cloud_id_for_compute_config_id(compute_config_id)
@@ -173,8 +199,13 @@ class AnyscaleClient(AnyscaleClientInterface):
         if cloud_name in self._cloud_id_cache:
             return self._cloud_id_cache[cloud_name]
 
-        workspace_cluster = self.get_current_workspace_cluster()
-        if workspace_cluster is not None:
+        if cloud_name is not None:
+            cloud_id = self._get_cloud_id_by_name(cloud_name)
+            if cloud_id is None:
+                raise RuntimeError(f"Cloud '{cloud_name}' not found.")
+        elif self.inside_workspace():
+            workspace_cluster = self.get_current_workspace_cluster()
+            assert workspace_cluster is not None
             # NOTE(edoakes): the Cluster model has a compute_config_config model that includes
             # its cloud ID, but it's not always populated.
             # TODO(edoakes): add cloud_id to the Cluster model to avoid a second RTT.
@@ -182,16 +213,30 @@ class AnyscaleClient(AnyscaleClientInterface):
                 workspace_cluster.cluster_compute_id
             )
         else:
-            result: Cloud = self._external_api_client.get_default_cloud().result
-            cloud_id = result.id
+            cloud_id = self._external_api_client.get_default_cloud().result.id
 
+        assert cloud_id is not None
         self._cloud_id_cache[cloud_name] = cloud_id
         return cloud_id
 
-    def create_anonymous_compute_config(self, config: ComputeTemplateConfig) -> str:
+    def get_cloud(self, *, cloud_id: str) -> Optional[Cloud]:
+        try:
+            cloud: Cloud = self._internal_api_client.get_cloud_api_v2_clouds_cloud_id_get(
+                cloud_id
+            ).result
+            return cloud
+        except InternalApiException as e:
+            if e.status == 404:
+                return None
+
+            raise e from None
+
+    def create_compute_config(
+        self, config: ComputeTemplateConfig, *, name: Optional[str] = None
+    ) -> str:
         return self._internal_api_client.create_compute_template_api_v2_compute_templates_post(
             create_compute_template=CreateComputeTemplate(
-                config=config, anonymous=True,
+                config=config, name=name, anonymous=name is None
             )
         ).result.id
 
@@ -203,7 +248,7 @@ class AnyscaleClient(AnyscaleClientInterface):
                 compute_config_id
             ).result
             return cluster_compute
-        except ApiException as e:
+        except InternalApiException as e:
             if e.status == 404:
                 return None
 
@@ -253,13 +298,16 @@ class AnyscaleClient(AnyscaleClientInterface):
                 standard_template = self._build_standard_compute_template_from_existing_auto_config(
                     workspace_config
                 )
-                return self.create_anonymous_compute_config(standard_template)
+                return self.create_compute_config(standard_template,)
             else:
                 return workspace_cluster.cluster_compute_id
 
-        # NOTE(edoakes): for some reason the API endpoint is called "cluster compute" but this
-        # is the non-deprecated API to use for compute configs.
-        return self._external_api_client.get_default_cluster_compute().result.id
+        return self.get_default_compute_config(cloud_id=self.get_cloud_id()).id
+
+    def get_default_compute_config(self, *, cloud_id: str) -> ClusterCompute:
+        return self._external_api_client.get_default_cluster_compute(
+            cloud_id=cloud_id,
+        ).result
 
     def _build_standard_compute_template_from_existing_auto_config(
         self, compute_config: ClusterComputeConfig
@@ -303,18 +351,41 @@ class AnyscaleClient(AnyscaleClientInterface):
                 cluster_env_build_id
             ).result
             return ImageURI.from_str(build.docker_image_name)
-        except ApiException as e:
+        except ExternalApiException as e:
             if e.status == 404:
                 return None
 
             raise e from None
 
-    def get_default_build_id(self) -> str:
-        """Get default build id.
+    def build_image_from_requirements(
+        self, cluster_env_name: str, base_build_id: str, requirements: List[str]
+    ) -> str:
+        if requirements:
+            self.logger.info(f"Building image with requirements: {requirements}.")
+            base_build = self._external_api_client.get_cluster_environment_build(
+                base_build_id
+            ).result
+            if (
+                base_build.status == ClusterEnvironmentBuildStatus.SUCCEEDED
+                and base_build.docker_image_name
+            ):
+                lines = [
+                    "# syntax=docker/dockerfile:1",
+                    f"FROM {base_build.docker_image_name}",
+                ]
+                for requirement in requirements:
+                    lines.append(f'RUN pip install "{requirement}"')
+                return self.get_cluster_env_build_id_from_containerfile(
+                    cluster_env_name, "\n".join(lines)
+                )
+            else:
+                raise RuntimeError(
+                    f"Base build {base_build_id} is not a successful build."
+                )
+        else:
+            return base_build_id
 
-        If running in a workspace, it will return the workspace's cluster environment build ID.
-        Else it will return the default cluster environment build ID.
-        """
+    def get_default_build_id(self) -> str:
         workspace_cluster = self.get_current_workspace_cluster()
         if workspace_cluster is not None:
             return workspace_cluster.cluster_environment_build_id
@@ -420,7 +491,7 @@ class AnyscaleClient(AnyscaleClientInterface):
                     raise RuntimeError(
                         f"Legacy cluster environment build '{identifier}' is not a successful build."
                     )
-            except ApiException as e:
+            except ExternalApiException as e:
                 if e.status == 404:
                     raise RuntimeError(
                         f"Legacy cluster environment '{identifier}' is not found."

{anyscale-0.24.10 → anyscale-0.24.12}/anyscale/_private/anyscale_client/common.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 
 from anyscale._private.models.image_uri import ImageURI
 from anyscale.client.openapi_client.models import (
+    Cloud,
     ComputeTemplateConfig,
     CreateInternalProductionJob,
     DecoratedComputeTemplate,
@@ -11,6 +12,7 @@ from anyscale.client.openapi_client.models import (
 from anyscale.sdk.anyscale_client.models import (
     ApplyServiceModel,
     Cluster,
+    ClusterCompute,
     ServiceModel,
 )
 from anyscale.utils.workspace_notification import WorkspaceNotification
@@ -20,7 +22,7 @@ from anyscale.utils.workspace_notification import WorkspaceNotification
 # Maybe just make it part of the release process to update it, or fetch the
 # default builds and get the latest one. The best thing to do is probably
 # to populate this in the backend.
-DEFAULT_RAY_VERSION = "2.9.2"
+DEFAULT_RAY_VERSION = "2.10.0"
 DEFAULT_PYTHON_VERSION = "py310"
 RUNTIME_ENV_PACKAGE_FORMAT = "pkg_{content_hash}.zip"
 
@@ -53,7 +55,7 @@ class AnyscaleClientInterface(ABC):
     def get_workspace_requirements_path(self) -> Optional[str]:
         """Returns the path to the workspace-managed requirements file.
 
-        Returns None if dependency tracking is disable or the file does not exist.
+        Returns None if dependency tracking is disable or the file does not exist or is not in a workspace.
         """
         raise NotImplementedError
 
@@ -83,7 +85,7 @@ class AnyscaleClientInterface(ABC):
     @abstractmethod
     def get_cloud_id(
         self, *, cloud_name: Optional[str] = None, compute_config_id: Optional[str]
-    ) -> Optional[str]:
+    ) -> str:
         """Get the cloud ID for the provided cloud name or compute config ID.
 
         If both arguments are None:
@@ -93,8 +95,21 @@ class AnyscaleClientInterface(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def create_anonymous_compute_config(self, config: ComputeTemplateConfig) -> str:
-        """Create an anonymous compute config and return its ID."""
+    def get_cloud(self, *, cloud_id: str) -> Optional[Cloud]:
+        """Get the cloud model for the provided cloud ID.
+
+        Returns `None` if the cloud ID was not found.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def create_compute_config(
+        self, config: ComputeTemplateConfig, *, name: Optional[str] = None
+    ) -> str:
+        """Create a compute config and return its ID.
+
+        If a name is not provided, the compute config will be "anonymous."
+        """
         raise NotImplementedError
 
     @abstractmethod
@@ -121,12 +136,25 @@ class AnyscaleClientInterface(ABC):
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_default_compute_config(self, *, cloud_id: str) -> ClusterCompute:
+        """Get the default compute config for the provided cloud ID."""
+        raise NotImplementedError
+
     @abstractmethod
     def get_default_build_id(self) -> str:
         """Get the default build id.
 
-        If running in a workspace, it will return the workspace's cluster environment build ID.
-        Else it will return the default cluster environment build ID.
+        If running in a workspace, it returns the workspace build id.
+        Else it returns the default build id.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def build_image_from_requirements(
+        self, cluster_env_name: str, base_build_id: str, requirements: List[str]
+    ) -> str:
+        """Build an image with the provided requirements and base_build_id.
         """
         raise NotImplementedError
 

{anyscale-0.24.10 → anyscale-0.24.12}/anyscale/_private/anyscale_client/fake_anyscale_client.py

@@ -9,6 +9,7 @@ from anyscale._private.anyscale_client.common import (
 from anyscale._private.models.image_uri import ImageURI
 from anyscale.cli_logger import BlockLogger
 from anyscale.client.openapi_client.models import (
+    Cloud,
     ComputeTemplateConfig,
     CreateInternalProductionJob,
     DecoratedComputeTemplate,
@@ -22,6 +23,8 @@ from anyscale.sdk.anyscale_client.models import (
     ApplyServiceModel,
     Cluster,
     ClusterCompute,
+    ClusterComputeConfig,
+    ComputeNodeType,
     ServiceEventCurrentState,
     ServiceModel,
 )
@@ -39,6 +42,7 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     BASE_UI_URL = "http://fake.com"
     CLOUD_BUCKET = "s3://fake-bucket/{cloud_id}"
     DEFAULT_CLOUD_ID = "fake-default-cloud-id"
+    DEFAULT_CLOUD_NAME = "fake-default-cloud"
     DEFAULT_PROJECT_ID = "fake-default-project-id"
     DEFAULT_CLUSTER_COMPUTE_ID = "fake-default-cluster-compute-id"
     DEFAULT_CLUSTER_ENV_BUILD_ID = "fake-default-cluster-env-build-id"
@@ -68,6 +72,32 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         self._upload_uri_mapping: Dict[str, str] = {}
         self._submitted_job: Optional[CreateInternalProductionJob] = None
 
+        # Cloud ID -> Cloud.
+        self._clouds: Dict[str, Cloud] = {
+            self.DEFAULT_CLOUD_ID: Cloud(
+                id=self.DEFAULT_CLOUD_ID,
+                name=self.DEFAULT_CLOUD_NAME,
+                local_vars_configuration=OPENAPI_NO_VALIDATION,
+            ),
+        }
+
+        # Cloud ID -> default ClusterCompute.
+        self._default_compute_configs: Dict[str, ClusterCompute] = {
+            self.DEFAULT_CLOUD_ID: ClusterCompute(
+                id=self.DEFAULT_CLUSTER_COMPUTE_ID,
+                config=ClusterComputeConfig(
+                    cloud_id=self.DEFAULT_CLOUD_ID,
+                    head_node_type=ComputeNodeType(
+                        name="default-head-node",
+                        instance_type="m5.2xlarge",
+                        resources={"CPU": 8, "GPU": 1},
+                    ),
+                    local_vars_configuration=OPENAPI_NO_VALIDATION,
+                ),
+                local_vars_configuration=OPENAPI_NO_VALIDATION,
+            ),
+        }
+
     def get_job_ui_url(self, job_id: str) -> str:
         return f"{self.BASE_UI_URL}/jobs/{job_id}"
 
@@ -107,7 +137,9 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         return self.get_current_workspace_cluster() is not None
 
     def get_workspace_requirements_path(self) -> Optional[str]:
-        return self._requirements_path
+        if self.inside_workspace():
+            return self._requirements_path
+        return None
 
     def get_current_workspace_cluster(self) -> Optional[Cluster]:
         return self._workspace_cluster
@@ -127,44 +159,52 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
 
         return self.DEFAULT_PROJECT_ID
 
-    def set_compute_config_id_to_cloud_id_mapping(
-        self, compute_config_id: str, cloud_id: str
-    ):
-        self._compute_config_id_to_cloud_id[compute_config_id] = cloud_id
-
     def get_cloud_id(
         self,
         *,
         cloud_name: Optional[str] = None,
         compute_config_id: Optional[str] = None,
-    ) -> Optional[str]:
+    ) -> str:
         assert not (cloud_name and compute_config_id)
         workspace_cluster = self.get_current_workspace_cluster()
         if workspace_cluster is not None:
             return self.WORKSPACE_CLOUD_ID
 
         if compute_config_id is not None:
-            return self._compute_config_id_to_cloud_id.get(compute_config_id)
+            return self._compute_configs[compute_config_id].config.cloud_id
 
         if cloud_name is None:
             return self.DEFAULT_CLOUD_ID
 
-        # TODO(edoakes): uncomment the below once non-default cloud is supported.
-        # return f"{cloud_name}-fake-id"
-        raise NotImplementedError("Only default cloud is currently implemented.")
+        return f"cloud-{cloud_name}-id"
+
+    def add_cloud(self, cloud: Cloud):
+        self._clouds[cloud.id] = cloud
+
+    def get_cloud(self, *, cloud_id: str) -> Optional[Cloud]:
+        return self._clouds.get(cloud_id, None)
 
     def add_compute_config(self, compute_config: DecoratedComputeTemplate):
         self._compute_configs[compute_config.id] = compute_config
         self._compute_config_name_to_id[compute_config.name] = compute_config.id
 
-    def create_anonymous_compute_config(self, config: ComputeTemplateConfig) -> str:
-        compute_config_id = f"compute-config-id-{str(uuid.uuid4())}"
+    def create_compute_config(
+        self, config: ComputeTemplateConfig, *, name: Optional[str] = None
+    ) -> str:
+        unique_id = str(uuid.uuid4())
+        compute_config_id = f"compute-config-id-{unique_id}"
+        if name is None:
+            anonymous = True
+            name = f"anonymous-compute-config-{unique_id}"
+        else:
+            anonymous = False
+
         self.add_compute_config(
             DecoratedComputeTemplate(
                 id=compute_config_id,
-                name=f"compute-config-{str(uuid.uuid4())}",
+                name=name,
                 config=config,
-                anonymous=True,
+                anonymous=anonymous,
                 local_vars_configuration=OPENAPI_NO_VALIDATION,
             ),
         )
@@ -185,7 +225,15 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         if workspace_cluster is not None:
             return workspace_cluster.cluster_compute_id
 
-        return self.DEFAULT_CLUSTER_COMPUTE_ID
+        return self.get_default_compute_config(cloud_id=self.get_cloud_id()).id
+
+    def set_default_compute_config(
+        self, compute_config: ClusterCompute, *, cloud_id: str
+    ):
+        self._default_compute_configs[cloud_id] = compute_config
+
+    def get_default_compute_config(self, *, cloud_id: str) -> ClusterCompute:
+        return self._default_compute_configs[cloud_id]
 
     def set_image_uri_mapping(self, image_uri: ImageURI, build_id: str):
         self._image_uri_to_build_id[image_uri] = build_id
@@ -198,9 +246,26 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
         workspace_cluster = self.get_current_workspace_cluster()
         if workspace_cluster is not None:
             return workspace_cluster.cluster_environment_build_id
-
         return self.DEFAULT_CLUSTER_ENV_BUILD_ID
 
+    def build_image_from_requirements(
+        self, cluster_env_name: str, base_build_id: str, requirements: List[str]
+    ) -> str:
+        if not requirements:
+            return base_build_id
+
+        image_uri = self.get_cluster_env_build_image_uri(base_build_id)
+        lines = [
+            "# syntax=docker/dockerfile:1",
+            f"FROM {image_uri}",
+        ]
+        for requirement in requirements:
+            lines.append(f'RUN pip install "{requirement}"')
+
+        return self.get_cluster_env_build_id_from_containerfile(
+            cluster_env_name=cluster_env_name, containerfile="\n".join(lines),
+        )
+
     def get_cluster_env_build_id_from_containerfile(
         self, cluster_env_name: str, containerfile: str  # noqa: ARG002
     ) -> str:
@@ -218,7 +283,7 @@ class FakeAnyscaleClient(AnyscaleClientInterface):
     def get_cluster_env_build_image_uri(
         self, cluster_env_build_id: str
     ) -> Optional[ImageURI]:
-        return self._build_id_to_image_uri.get(cluster_env_build_id, None)
+        return self._build_id_to_image_uri.get(cluster_env_build_id)
 
     def update_service(self, model: ServiceModel):
         self._services[model.id] = model

{anyscale-0.24.10 → anyscale-0.24.12}/anyscale/_private/models/__init__.py

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

{anyscale-0.24.10 → anyscale-0.24.12}/anyscale/_private/models/model_base.py

@@ -1,6 +1,7 @@
 from dataclasses import asdict, fields
 from enum import Enum
-from typing import Any, Dict, Iterable, Tuple, TypeVar
+import inspect
+from typing import Any, Dict, Iterable, Optional, Tuple, TypeVar
 
 import yaml
 
@@ -28,6 +29,9 @@ class ModelBase:
 
         Looks for methods with the name: `_validate_{field}`. The method will be called
         with the field value as its sole argument.
+
+        If the validator has a return type annotation, the field will be updated to the
+        returned value.
         """
         for field in fields(self):
             validator = getattr(self, f"_validate_{field.name}", None)
@@ -36,15 +40,45 @@ class ModelBase:
                     f"Model '{type(self).__name__}' is missing validator method for field '{field.name}'."
                 )
 
-            validator(getattr(self, field.name))
+            signature: inspect.Signature = inspect.signature(validator)
+            if len(signature.parameters) != 1:
+                raise TypeError(
+                    f"Validator for field '{field.name}' must take the field value as its only argument."
+                )
+            elif field.name not in signature.parameters:
+                raise TypeError(
+                    f"Validator for field '{field.name}' has invalid parameter name (must match the field name)."
+                )
+            elif signature.parameters[field.name].annotation == inspect.Parameter.empty:
+                raise TypeError(
+                    f"Validator for field '{field.name}' is missing a type annotation (should be '{field.type}')."
+                )
+            elif signature.parameters[field.name].annotation != field.type:
+                raise TypeError(
+                    f"Validator for field '{field.name}' has the wrong type annotation (should be '{field.type}')."
+                )
+
+            maybe_updated_field_value = validator(getattr(self, field.name))
+            if signature.return_annotation != inspect.Signature.empty:
+                # Only update the value if the validator has a return type annotation.
+                object.__setattr__(self, field.name, maybe_updated_field_value)
 
     def __post_init__(self):
         self._run_validators()
 
     @classmethod
-    def from_yaml(cls, path: str):
+    def from_dict(cls, d: Dict[str, Any]) -> "ModelBase":
+        return cls(**d)
+
+    @classmethod
+    def from_yaml(
+        cls, path: str, override: Optional[Dict[str, Any]] = None
+    ) -> "ModelBase":
         with open(path) as f:
-            return cls(**yaml.safe_load(f))
+            args = yaml.safe_load(f) or {}
+            if override:
+                args.update(override)
+            return cls.from_dict(args)
 
     def to_dict(self, *, exclude_none: bool = True) -> Dict[str, Any]:
         """Convert the model to a dictionary representation.
@@ -74,10 +108,11 @@ class ModelBase:
 
         All fields in the constructor are supported. Those not provided will be unchanged.
         """
-        self_dict = self.to_dict(exclude_none=False)
         new_instance_kwargs = {
-            field: kwargs.pop(field) if field in kwargs else self_dict[field]
-            for field in self_dict
+            field.name: kwargs.pop(field.name)
+            if field.name in kwargs
+            else getattr(self, field.name)
+            for field in fields(self)
         }
         if len(kwargs) > 0:
             raise ValueError(

anyscale-0.24.12/anyscale/_private/sdk/base_sdk.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+from anyscale._private.anyscale_client import (
+    AnyscaleClient,
+    AnyscaleClientInterface,
+)
+from anyscale.cli_logger import BlockLogger
+
+
+class BaseSDK:
+    """Shared parent class for all 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

anyscale-0.24.12/anyscale/_private/workload/__init__.py

@@ -0,0 +1,2 @@
+from anyscale._private.workload.workload_config import WorkloadConfig
+from anyscale._private.workload.workload_sdk import WorkloadSDK