anyscale 0.26.42__py3-none-any.whl → 0.26.44__py3-none-any.whl

anyscale/compute_config/_private/compute_config_sdk.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 from anyscale._private.sdk.base_sdk import BaseSDK
 from anyscale.client.openapi_client.models import (
     Cloud,
-    CloudProviders,
+    CloudDeploymentComputeConfig,
     ComputeNodeType,
     ComputeTemplateConfig,
     DecoratedComputeTemplate,
@@ -19,6 +19,7 @@ from anyscale.compute_config.models import (
     ComputeConfigVersion,
     HeadNodeConfig,
     MarketType,
+    MultiDeploymentComputeConfig,
     WorkerNodeGroupConfig,
 )
 from anyscale.sdk.anyscale_client.models import ClusterComputeConfig
@@ -31,26 +32,6 @@ UNSCHEDULABLE_RESOURCES = Resources(cpu=0, gpu=0)
 
 
 class PrivateComputeConfigSDK(BaseSDK):
-    def _populate_advanced_instance_config(
-        self,
-        config: Union[ComputeConfig, HeadNodeConfig, WorkerNodeGroupConfig],
-        api_model: Union[ComputeTemplateConfig, ComputeNodeType, WorkerNodeType],
-        *,
-        cloud: Cloud,
-    ):
-        """Populates the appropriate advanced instance config field of the API model in place."""
-        if not config.advanced_instance_config:
-            return
-
-        # Always pass the advanced configuration through `advanced_configurations_json`.
-        # After fully migrated, we can stop setting the cloud-specific advanced configurations here.
-        api_model.advanced_configurations_json = config.advanced_instance_config
-
-        if cloud.provider == CloudProviders.AWS:
-            api_model.aws_advanced_configurations_json = config.advanced_instance_config
-        elif cloud.provider == CloudProviders.GCP:
-            api_model.gcp_advanced_configurations_json = config.advanced_instance_config
-
     def _convert_resource_dict_to_api_model(
         self, resource_dict: Optional[Dict[str, float]]
     ) -> Optional[Resources]:
@@ -103,18 +84,13 @@ class PrivateComputeConfigSDK(BaseSDK):
                 if config.resources is not None or schedulable_by_default
                 else UNSCHEDULABLE_RESOURCES,
                 flags=flags or None,
-            )
-            self._populate_advanced_instance_config(
-                config, api_model, cloud=cloud,
+                advanced_configurations_json=config.advanced_instance_config or None,
             )
 
         return api_model
 
     def _convert_worker_node_group_configs_to_api_models(
-        self,
-        configs: Optional[List[Union[Dict, WorkerNodeGroupConfig]]],
-        *,
-        cloud: Cloud,
+        self, configs: Optional[List[Union[Dict, WorkerNodeGroupConfig]]],
     ) -> Optional[List[WorkerNodeType]]:
         if configs is None:
             return None
@@ -139,9 +115,7 @@ class PrivateComputeConfigSDK(BaseSDK):
                 in {MarketType.SPOT, MarketType.PREFER_SPOT},
                 fallback_to_ondemand=config.market_type == MarketType.PREFER_SPOT,
                 flags=flags or None,
-            )
-            self._populate_advanced_instance_config(
-                config, api_model, cloud=cloud,
+                advanced_configurations_json=config.advanced_instance_config or None,
             )
             api_models.append(api_model)
 
@@ -149,7 +123,7 @@ class PrivateComputeConfigSDK(BaseSDK):
 
     def _convert_compute_config_to_api_model(
         self, compute_config: ComputeConfig
-    ) -> ComputeTemplateConfig:
+    ) -> CloudDeploymentComputeConfig:
         # We should only make the head node schedulable when it's the *only* node in the cluster.
         # `worker_nodes=None` uses the default serverless config, so this only happens if `worker_nodes`
         # is explicitly set to an empty list.
@@ -172,29 +146,31 @@ class PrivateComputeConfigSDK(BaseSDK):
         if compute_config.max_resources:
             flags["max_resources"] = compute_config.max_resources
 
-        api_model = ComputeTemplateConfig(
-            cloud_id=cloud_id,
+        return CloudDeploymentComputeConfig(
+            cloud_deployment=compute_config.cloud_deployment,
             allowed_azs=compute_config.zones,
-            region="",
             head_node_type=self._convert_head_node_config_to_api_model(
                 compute_config.head_node,
                 cloud=cloud,
-                schedulable_by_default=compute_config.worker_nodes == [],
+                schedulable_by_default=(
+                    not compute_config.worker_nodes
+                    and not compute_config.auto_select_worker_config
+                ),
             ),
             worker_node_types=self._convert_worker_node_group_configs_to_api_models(
-                compute_config.worker_nodes, cloud=cloud,
+                compute_config.worker_nodes,
             ),
             auto_select_worker_config=compute_config.auto_select_worker_config,
             flags=flags,
+            advanced_configurations_json=compute_config.advanced_instance_config
+            or None,
         )
-        self._populate_advanced_instance_config(
-            compute_config, api_model, cloud=cloud,
-        )
-        return api_model
 
     def create_compute_config(
         self, compute_config: ComputeConfig, *, name: Optional[str] = None
     ) -> Tuple[str, str]:
+        """Register the provided compute config and return its internal ID."""
+
         if name is not None:
             _, version = parse_cluster_compute_name_version(name)
             if version is not None:
@@ -203,35 +179,101 @@ class PrivateComputeConfigSDK(BaseSDK):
                     "The latest version tag will be generated and returned."
                 )
 
-        """Register the provided compute config and return its internal ID."""
-        compute_config_api_model = self._convert_compute_config_to_api_model(
-            compute_config
+        # Returns the default cloud if user-provided cloud is not specified (`None`).
+        cloud_id = self.client.get_cloud_id(cloud_name=compute_config.cloud)  # type: ignore
+
+        deployment_config = self._convert_compute_config_to_api_model(compute_config)
+
+        compute_config_api_model = ComputeTemplateConfig(
+            cloud_id=cloud_id,
+            deployment_configs=[deployment_config],
+            # For compatibility, continue setting the top-level fields.
+            allowed_azs=deployment_config.allowed_azs,
+            head_node_type=deployment_config.head_node_type,
+            worker_node_types=deployment_config.worker_node_types,
+            auto_select_worker_config=deployment_config.auto_select_worker_config,
+            flags=deployment_config.flags,
+            advanced_configurations_json=deployment_config.advanced_configurations_json
+            or None,
         )
+
         full_name, compute_config_id = self.client.create_compute_config(
             compute_config_api_model, name=name
         )
         self.logger.info(f"Created compute config: '{full_name}'")
         ui_url = self.client.get_compute_config_ui_url(
-            compute_config_id, cloud_id=compute_config_api_model.cloud_id
+            compute_config_id, cloud_id=cloud_id
         )
         self.logger.info(f"View the compute config in the UI: '{ui_url}'")
         return full_name, compute_config_id
 
-    def _convert_api_model_to_advanced_instance_config(
+    def create_multi_deployment_compute_config(
         self,
-        api_model: Union[DecoratedComputeTemplate, ComputeNodeType, WorkerNodeType],
+        compute_config: MultiDeploymentComputeConfig,
         *,
-        cloud: Cloud,
+        name: Optional[str] = None,
+    ) -> Tuple[str, str]:
+        """Register the provided multi-deployment compute config and return its internal ID."""
+        if name is not None:
+            _, version = parse_cluster_compute_name_version(name)
+            if version is not None:
+                raise ValueError(
+                    "A version tag cannot be provided when creating a compute config. "
+                    "The latest version tag will be generated and returned."
+                )
+
+        # Returns the default cloud if user-provided cloud is not specified (`None`).
+        cloud_id = self.client.get_cloud_id(cloud_name=compute_config.cloud)  # type: ignore
+
+        # Convert each compute config to the CloudDeploymentComputeConfig API model.
+        assert compute_config.configs
+        deployment_configs = []
+        for config in compute_config.configs:
+            assert isinstance(config, ComputeConfig)
+            deployment_configs.append(self._convert_compute_config_to_api_model(config))
+        default_config = deployment_configs[0]
+
+        compute_config_api_model = ComputeTemplateConfig(
+            cloud_id=cloud_id,
+            deployment_configs=deployment_configs,
+            # For compatibility, use the first deployment config to set the top-level fields.
+            allowed_azs=default_config.allowed_azs,
+            head_node_type=default_config.head_node_type,
+            worker_node_types=default_config.worker_node_types,
+            auto_select_worker_config=default_config.auto_select_worker_config,
+            flags=default_config.flags,
+            advanced_configurations_json=default_config.advanced_configurations_json
+            or None,
+        )
+        full_name, compute_config_id = self.client.create_compute_config(
+            compute_config_api_model, name=name
+        )
+        self.logger.info(f"Created compute config: '{full_name}'")
+
+        # TODO(janet): add this back after the UI has been updated to support multi-deployment compute configs.
+        # ui_url = self.client.get_compute_config_ui_url(
+        #     compute_config_id, cloud_id=cloud_id
+        # )
+        # self.logger.info(f"View the compute config in the UI: '{ui_url}'")
+
+        return full_name, compute_config_id
+
+    def _convert_api_model_to_advanced_instance_config(
+        self,
+        api_model: Union[
+            DecoratedComputeTemplateConfig, ComputeNodeType, WorkerNodeType
+        ],
     ) -> Optional[Dict]:
         if api_model.advanced_configurations_json:
             return api_model.advanced_configurations_json
 
-        if cloud.provider == CloudProviders.AWS:
-            return api_model.aws_advanced_configurations_json or None
-        elif cloud.provider == CloudProviders.GCP:
-            return api_model.gcp_advanced_configurations_json or None
-        else:
-            return None
+        # Only one of aws_advanced_configurations_json or gcp_advanced_configurations_json will be set.
+        if api_model.aws_advanced_configurations_json:
+            return api_model.aws_advanced_configurations_json
+        if api_model.gcp_advanced_configurations_json:
+            return api_model.gcp_advanced_configurations_json
+
+        return None
 
     def _convert_api_model_to_resource_dict(
         self, resources: Optional[Resources]
@@ -253,7 +295,7 @@ class PrivateComputeConfigSDK(BaseSDK):
         }
 
     def _convert_api_model_to_head_node_config(
-        self, api_model: ComputeNodeType, *, cloud: Cloud
+        self, api_model: ComputeNodeType
     ) -> HeadNodeConfig:
         flags: Dict[str, Any] = deepcopy(api_model.flags) or {}
 
@@ -268,14 +310,14 @@ class PrivateComputeConfigSDK(BaseSDK):
             instance_type=api_model.instance_type,
             resources=self._convert_api_model_to_resource_dict(api_model.resources),
             advanced_instance_config=self._convert_api_model_to_advanced_instance_config(
-                api_model, cloud=cloud,
+                api_model,
             ),
             flags=flags or None,
             cloud_deployment=cloud_deployment,
         )
 
     def _convert_api_models_to_worker_node_group_configs(
-        self, api_models: List[WorkerNodeType], *, cloud: Cloud
+        self, api_models: List[WorkerNodeType]
     ) -> List[WorkerNodeGroupConfig]:
         # TODO(edoakes): support advanced_instance_config.
         configs = []
@@ -315,7 +357,7 @@ class PrivateComputeConfigSDK(BaseSDK):
                         api_model.resources
                     ),
                     advanced_instance_config=self._convert_api_model_to_advanced_instance_config(
-                        api_model, cloud=cloud,
+                        api_model,
                     ),
                     min_nodes=min_nodes,
                     max_nodes=max_nodes,
@@ -327,6 +369,54 @@ class PrivateComputeConfigSDK(BaseSDK):
 
         return configs
 
+    def _convert_cloud_deployment_compute_config_api_model_to_compute_config(
+        self, cloud_name: str, api_model: CloudDeploymentComputeConfig,
+    ) -> ComputeConfig:
+        worker_nodes = None
+        if not api_model.auto_select_worker_config:
+            if api_model.worker_node_types is not None:
+                # Convert worker node types when they are present.
+                worker_nodes = self._convert_api_models_to_worker_node_group_configs(
+                    api_model.worker_node_types
+                )
+            else:
+                # An explicit head-node-only cluster (no worker nodes configured).
+                worker_nodes = []
+
+        zones = None
+        # NOTE(edoakes): the API returns '["any"]' if no AZs are passed in on the creation path.
+        if api_model.allowed_azs not in [["any"], []]:
+            zones = api_model.allowed_azs
+
+        enable_cross_zone_scaling = False
+        flags: Dict[str, Any] = deepcopy(api_model.flags) or {}
+        enable_cross_zone_scaling = flags.pop("allow-cross-zone-autoscaling", False)
+        min_resources = flags.pop("min_resources", None)
+        max_resources = flags.pop("max_resources", None)
+        if max_resources is None:
+            max_resources = {}
+            max_cpus = flags.pop("max-cpus", None)
+            if max_cpus:
+                max_resources["CPU"] = max_cpus
+            max_gpus = flags.pop("max-gpus", None)
+            if max_gpus:
+                max_resources["GPU"] = max_gpus
+
+        return ComputeConfig(
+            cloud=cloud_name,
+            cloud_deployment=api_model.cloud_deployment,
+            zones=zones,
+            advanced_instance_config=api_model.advanced_configurations_json or None,
+            enable_cross_zone_scaling=enable_cross_zone_scaling,
+            head_node=self._convert_api_model_to_head_node_config(
+                api_model.head_node_type
+            ),
+            worker_nodes=worker_nodes,
+            min_resources=min_resources,
+            max_resources=max_resources or None,
+            flags=flags,
+        )
+
     def _convert_api_model_to_compute_config_version(
         self, api_model: DecoratedComputeTemplate  # noqa: ARG002
     ) -> ComputeConfigVersion:
@@ -338,12 +428,37 @@ class PrivateComputeConfigSDK(BaseSDK):
                 "This should never happen; please reach out to Anyscale support."
             )
 
+        configs = None
+        if api_model_config.deployment_configs:
+            configs = [
+                self._convert_cloud_deployment_compute_config_api_model_to_compute_config(
+                    cloud.name, config
+                )
+                for config in api_model_config.deployment_configs
+            ]
+            if len(configs) == 1:
+                # If there's only one deployment config, return it directly.
+                return ComputeConfigVersion(
+                    name=f"{api_model.name}:{api_model.version}",
+                    id=api_model.id,
+                    config=configs[0],
+                )
+            return ComputeConfigVersion(
+                name=f"{api_model.name}:{api_model.version}",
+                id=api_model.id,
+                multi_deployment_config=MultiDeploymentComputeConfig(
+                    cloud=cloud.name, configs=configs,
+                ),
+            )
+
+        # If there are no deployment configs, this is a compute config for a single cloud deployment - parse the top-level fields.
+
         worker_nodes = None
         if not api_model_config.auto_select_worker_config:
             if api_model_config.worker_node_types is not None:
                 # Convert worker node types when they are present.
                 worker_nodes = self._convert_api_models_to_worker_node_group_configs(
-                    api_model_config.worker_node_types, cloud=cloud,
+                    api_model_config.worker_node_types
                 )
             else:
                 # An explicit head-node-only cluster (no worker nodes configured).
@@ -375,11 +490,11 @@ class PrivateComputeConfigSDK(BaseSDK):
                 cloud=cloud.name,
                 zones=zones,
                 advanced_instance_config=self._convert_api_model_to_advanced_instance_config(
-                    api_model_config, cloud=cloud,
+                    api_model_config
                 ),
                 enable_cross_zone_scaling=enable_cross_zone_scaling,
                 head_node=self._convert_api_model_to_head_node_config(
-                    api_model_config.head_node_type, cloud=cloud
+                    api_model_config.head_node_type
                 ),
                 worker_nodes=worker_nodes,  # type: ignore
                 min_resources=min_resources,

anyscale/compute_config/commands.py

@@ -2,7 +2,11 @@ from typing import Optional
 
 from anyscale._private.sdk import sdk_command
 from anyscale.compute_config._private.compute_config_sdk import PrivateComputeConfigSDK
-from anyscale.compute_config.models import ComputeConfig, ComputeConfigVersion
+from anyscale.compute_config.models import (
+    ComputeConfig,
+    ComputeConfigVersion,
+    MultiDeploymentComputeConfig,
+)
 
 
 _COMPUTE_CONFIG_SDK_SINGLETON_KEY = "compute_config_sdk"
@@ -58,6 +62,67 @@ def create(
     return full_name
 
 
+_CREATE_MULTI_DEPLOYMENT_EXAMPLE = """
+import anyscale
+from anyscale.compute_config.models import MultiDeploymentComputeConfig, ComputeConfig, HeadNodeConfig, WorkerNodeGroupConfig
+config = MultiDeploymentComputeConfig(
+    configs=[
+        ComputeConfig(
+            cloud_deployment="vm-aws-us-west-1",
+            head_node=HeadNodeConfig(
+                instance_type="m5.2xlarge",
+            ),
+            worker_nodes=[
+                WorkerNodeGroupConfig(
+                    instance_type="m5.4xlarge",
+                    min_nodes=1,
+                    max_nodes=10,
+                ),
+            ],
+        ),
+        ComputeConfig(
+            cloud_deployment="vm-aws-us-west-2",
+            head_node=HeadNodeConfig(
+                instance_type="m5.2xlarge",
+            ),
+            worker_nodes=[
+                WorkerNodeGroupConfig(
+                    instance_type="m5.4xlarge",
+                    min_nodes=1,
+                    max_nodes=10,
+                ),
+            ],
+        )
+    ]
+)
+full_name: str = anyscale.compute_config.create_multi_deployment(config, name="my-compute-config")
+"""
+
+_CREATE_MULTI_DEPLOYMENT_ARG_DOCSTRINGS = {
+    "config": "The config options defining the multi-deployment compute config.",
+    "name": "The name of the compute config. This should *not* include a version tag. If a name is not provided, one will be automatically generated.",
+}
+
+
+@sdk_command(
+    _COMPUTE_CONFIG_SDK_SINGLETON_KEY,
+    PrivateComputeConfigSDK,
+    doc_py_example=_CREATE_MULTI_DEPLOYMENT_EXAMPLE,
+    arg_docstrings=_CREATE_MULTI_DEPLOYMENT_ARG_DOCSTRINGS,
+)
+def create_multi_deployment(
+    config: MultiDeploymentComputeConfig,
+    *,
+    name: Optional[str],
+    _private_sdk: Optional[PrivateComputeConfigSDK] = None,
+) -> str:
+    """EXPERIMENTAL. Create a new version of a compute config with multiple possible cloud deployments.
+    Returns the full name of the registered compute config, including the version.
+    """
+    full_name, _ = _private_sdk.create_multi_deployment_compute_config(config, name=name)  # type: ignore
+    return full_name
+
+
 _GET_EXAMPLE = """
 import anyscale
 from anyscale.compute_config.models import ComputeConfig

anyscale/compute_config/models.py

@@ -417,6 +417,19 @@ advanced_instance_config: # (Optional) Defaults to no advanced configurations.
         if cloud is not None and not isinstance(cloud, str):
             raise TypeError("'cloud' must be a string")
 
+    cloud_deployment: Optional[str] = field(
+        default=None,
+        repr=False,
+        metadata={
+            "docstring": "The cloud deployment to use for this workload. Defaults to the primary deployment of the Cloud.",
+            "customer_hosted_only": True,
+        },
+    )
+
+    def _validate_cloud_deployment(self, cloud_deployment: Optional[str]):
+        if cloud_deployment is not None and not isinstance(cloud_deployment, str):
+            raise TypeError("'cloud_deployment' must be a string")
+
     head_node: Union[HeadNodeConfig, Dict, None] = field(
         default=None,
         repr=False,
@@ -586,6 +599,129 @@ advanced_instance_config: # (Optional) Defaults to no advanced configurations.
             )
 
 
+@dataclass(frozen=True)
+class MultiDeploymentComputeConfig(ModelBase):
+    """EXPERIMENTAL. Compute configuration for a cluster with multiple possible cloud deployments."""
+
+    __doc_py_example__ = """
+from anyscale.compute_config.models import (
+    MultiDeploymentComputeConfig, ComputeConfig, HeadNodeConfig, WorkerNodeGroupConfig
+)
+config = MultiDeploymentComputeConfig(
+    configs=[
+        ComputeConfig(
+            cloud_deployment="vm-aws-us-west-1",
+            head_node=HeadNodeConfig(
+                instance_type="m5.2xlarge",
+            ),
+            worker_nodes=[
+                WorkerNodeGroupConfig(
+                    instance_type="m5.4xlarge",
+                    min_nodes=1,
+                    max_nodes=10,
+                ),
+            ],
+        ),
+        ComputeConfig(
+            cloud_deployment="vm-aws-us-west-2",
+            head_node=HeadNodeConfig(
+                instance_type="m5.2xlarge",
+            ),
+            worker_nodes=[
+                WorkerNodeGroupConfig(
+                    instance_type="m5.4xlarge",
+                    min_nodes=1,
+                    max_nodes=10,
+                ),
+            ],
+        )
+    ]
+)
+"""
+
+    __doc_yaml_example__ = """
+cloud: my-cloud
+configs:
+- cloud_deployment: vm-aws-us-west-1
+  head_node:
+    instance_type: m5.2xlarge
+  worker_nodes:
+  - instance_type: m5.4xlarge
+    min_nodes: 1
+    max_nodes: 10
+- cloud_deployment: vm-aws-us-west-2
+  head_node:
+    instance_type: m5.2xlarge
+  worker_nodes:
+  - instance_type: m5.4xlarge
+    min_nodes: 1
+    max_nodes: 10
+"""
+
+    cloud: Optional[str] = field(
+        default=None,
+        metadata={
+            "docstring": "The Anyscale Cloud to run this workload on. If not provided, the organization default will be used (or, if running in a workspace, the cloud of the workspace)."
+        },
+    )
+
+    def _validate_cloud(self, cloud: Optional[str]):
+        if cloud is not None and not isinstance(cloud, str):
+            raise TypeError("'cloud' must be a string")
+
+    configs: List[Union[ComputeConfig, Dict]] = field(
+        default_factory=list,
+        repr=False,
+        metadata={
+            "docstring": "List of compute configurations, one for each cloud deployment.",
+            "customer_hosted_only": True,
+        },
+    )
+
+    def _validate_configs(
+        self, configs: List[Union[ComputeConfig, Dict]]
+    ) -> List[ComputeConfig]:
+        if not isinstance(configs, list) or not all(
+            isinstance(c, (dict, ComputeConfig)) for c in configs
+        ):
+            raise TypeError(
+                "'configs' must be a list of ComputeConfigs or corresponding dicts"
+            )
+
+        config_models: List[ComputeConfig] = []
+        unique_clouds = set()
+        unique_deployments = set()
+        for config in configs:
+            if isinstance(config, dict):
+                config = ComputeConfig.from_dict(config)
+
+            assert isinstance(config, ComputeConfig)
+            config_models.append(config)
+
+            if not config.cloud_deployment:
+                raise ValueError("'cloud_deployment' is required for each config.")
+
+            if config.cloud:
+                unique_clouds.add(config.cloud)
+
+            unique_deployments.add(config.cloud_deployment)
+
+        if len(unique_clouds) > 1:
+            raise ValueError("'cloud' must be the same for all configs.")
+
+        if len(unique_deployments) != len(configs):
+            raise ValueError(
+                "'cloud_deployment' must be unique for each compute configuration."
+            )
+
+        if len(configs) == 0:
+            raise ValueError(
+                "'configs' must include at least one compute configuration."
+            )
+
+        return config_models
+
+
 @dataclass(frozen=True)
 class ComputeConfigVersion(ModelBase):
     """Details of a created version of a compute config.
@@ -639,8 +775,29 @@ config:
         if not isinstance(id, str):
             raise TypeError("'id' must be a string.")
 
-    config: ComputeConfig = field(metadata={"docstring": "The compute configuration."},)
+    config: Optional[ComputeConfig] = field(
+        default=None, metadata={"docstring": "The compute configuration."},
+    )
 
-    def _validate_config(self, config: ComputeConfig):
-        if not isinstance(config, ComputeConfig):
+    def _validate_config(self, config: Optional[ComputeConfig]):
+        if config is not None and not isinstance(config, ComputeConfig):
             raise TypeError("'config' must be a ComputeConfig")
+
+    multi_deployment_config: Optional[MultiDeploymentComputeConfig] = field(
+        default=None,
+        repr=False,
+        metadata={
+            "docstring": "Compute configuration for a cluster with multiple possible cloud deployments.",
+            "customer_hosted_only": True,
+        },
+    )
+
+    def _validate_multi_deployment_config(
+        self, multi_deployment_config: Optional[MultiDeploymentComputeConfig]
+    ):
+        if multi_deployment_config is not None and not isinstance(
+            multi_deployment_config, MultiDeploymentComputeConfig
+        ):
+            raise TypeError(
+                "'multi_deployment_config' must be a MultiDeploymentComputeConfig"
+            )

anyscale/conf.py

@@ -16,7 +16,7 @@ ANYSCALE_IAM_ROLE_NAME = "anyscale-iam-role"
 # Minimum default Ray version to return when a user either asks for `anyscale.connect required_ray_version`
 # or when a Default Cluster Env is used
 # TODO(ilr/nikita) Convert this to a backend call for the most recent Ray Version in the Dataplane!
-MINIMUM_RAY_VERSION = "1.7.0"
+MINIMUM_RAY_VERSION = "2.7.0"
 
 IDLE_TIMEOUT_DEFAULT_MINUTES = 120