anyscale 0.26.68__py3-none-any.whl → 0.26.70__py3-none-any.whl

anyscale/service/_private/service_sdk.py

@@ -1,12 +1,19 @@
 import asyncio
 import copy
-from typing import Any, Dict, List, Optional, Union
+import json
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from anyscale._private.models.model_base import ResultIterator
 from anyscale._private.workload import WorkloadSDK
+from anyscale.client.openapi_client.models.apply_production_service_multi_version_v2_model import (
+    ApplyProductionServiceMultiVersionV2Model,
+)
 from anyscale.client.openapi_client.models.decorated_production_service_v2_api_model import (
     DecoratedProductionServiceV2APIModel,
 )
+from anyscale.client.openapi_client.models.decorated_production_service_v2_version_api_model import (
+    DecoratedProductionServiceV2VersionAPIModel,
+)
 from anyscale.client.openapi_client.models.decoratedlistserviceapimodel_list_response import (
     DecoratedlistserviceapimodelListResponse,
 )
@@ -21,6 +28,7 @@ from anyscale.sdk.anyscale_client.models import (
     ProductionServiceV2VersionModel,
     Protocols,
     RayGCSExternalStorageConfig as APIRayGCSExternalStorageConfig,
+    RolloutStrategy,
     ServiceConfig as ExternalAPIServiceConfig,
     ServiceEventCurrentState,
     ServiceSortField,
@@ -124,16 +132,21 @@ class PrivateServiceSDK(WorkloadSDK):
         canary_percent: Optional[int],
     ):
         """Log user-facing information about a deployed service."""
-        version_id_info = "version ID: {version_id}".format(
-            version_id=self._get_user_facing_service_version_id(
-                service.canary_version
-                if service.canary_version is not None
-                else service.primary_version
+        if not service.primary_version:
+            version_info = "versions: {versions}".format(
+                versions=[v.version for v in service.versions]
+            )
+        else:
+            version_info = "version ID: {version_id}".format(
+                version_id=self._get_user_facing_service_version_id(
+                    service.canary_version
+                    if service.canary_version is not None
+                    else service.primary_version
+                )
             )
-        )
         details = (
             "("
-            + version_id_info
+            + version_info
             + (
                 ")"
                 if canary_percent is None
@@ -270,6 +283,7 @@ class PrivateServiceSDK(WorkloadSDK):
         )
         return ApplyProductionServiceV2Model(
             name=name,
+            version=config.version_name,
             project_id=project_id,
             ray_serve_config=self._build_ray_serve_config(config),
             build_id=existing_config.build_id,
@@ -288,10 +302,12 @@ class PrivateServiceSDK(WorkloadSDK):
         self,
         name: str,
         config: ServiceConfig,
+        rollout_strategy: RolloutStrategy,
         *,
         canary_percent: Optional[int] = None,
         max_surge_percent: Optional[int] = None,
         existing_service: Optional[DecoratedProductionServiceV2APIModel] = None,
+        traffic_percent: Optional[int] = None,
     ) -> ApplyProductionServiceV2Model:
         """Build the ApplyProductionServiceV2Model for a rolling update."""
 
@@ -399,13 +415,14 @@ class PrivateServiceSDK(WorkloadSDK):
 
         return ApplyProductionServiceV2Model(
             name=name,
+            version=config.version_name,
             project_id=project_id,
             ray_serve_config=self._build_ray_serve_config(config),
             build_id=build_id,
             compute_config_id=compute_config_id,
             canary_percent=canary_percent,
             max_surge_percent=max_surge_percent,
-            rollout_strategy="ROLLOUT",
+            rollout_strategy=rollout_strategy,
             config=ExternalAPIServiceConfig(
                 access=AccessConfig(use_bearer_token=config.query_auth_token_enabled),
                 protocols=Protocols(grpc=self._build_grpc_protocol_config(config)),
@@ -413,36 +430,319 @@ class PrivateServiceSDK(WorkloadSDK):
             ),
             ray_gcs_external_storage_config=ray_gcs_external_storage_config,
             tracing_config=tracing_config,
+            traffic_percent=traffic_percent,
         )
 
-    def deploy(  # noqa: PLR0912
+    def _build_apply_service_model_for_multi_version(
         self,
-        config: ServiceConfig,
+        name: str,
+        cloud: Optional[str],
+        project: Optional[str],
+        configs: List[ServiceConfig],
+        existing_service: Optional[DecoratedProductionServiceV2APIModel],
+        versions: List[Dict[str, Any]],
+    ) -> ApplyProductionServiceV2Model:
+        cloud_id = self.client.get_cloud_id(cloud_name=cloud)
+        project_id = self.client.get_project_id(parent_cloud_id=cloud_id, name=project)
+
+        # implement a map between version name and config file
+        # This way, we can iterate over the version config and corresponding config file to the _build_apply_service_model_for_rollout function
+        # Also, maybe add an assertion to confirm the version name is the same as the config file name.
+        # I also need to add a validation logic to confirm if all the version config passed(the version name) all has the corresponding config file.
+        version_service_map = self._get_service_version_map(configs, versions, existing_service)  # type: ignore
+        existing_versions: Dict[str, DecoratedProductionServiceV2VersionAPIModel] = {}
+        if existing_service is not None:
+            existing_versions = {
+                v.version: v
+                for v in self.client.get_service_versions(existing_service.id)
+            }
+
+        service_versions: List[ApplyProductionServiceV2Model] = []
+        for _, (config, version) in version_service_map.items():
+            version_name = version["name"]
+            traffic_percent = version["traffic_percent"]
+            # If config is None, it means the version is already deployed, and the user is likely to be only updating the traffic/capacity percent without serve config update.
+            if config is None:
+                if version_name not in existing_versions:
+                    raise ValueError(
+                        f"Version {version_name} does not exist in the existing service."
+                    )
+                existing_version = existing_versions[version_name]
+
+                service_version = ApplyProductionServiceV2Model(
+                    name=name,
+                    project_id=project_id,
+                    ray_serve_config=existing_version.ray_serve_config,
+                    build_id=existing_version.build_id,
+                    compute_config_id=existing_version.compute_config_id,
+                    rollout_strategy=RolloutStrategy.MULTI_VERSION,
+                    # TODO(doyoung): "config" is a service level config, so I'm assuming this is not necessary when this model is
+                    # representing a service version. If not, may need to add and store 'config' field in the version model, ProductionServiceV2VersionModel,
+                    # from the backend when the service version first gets created so it can be read from here for reconstruction.
+                    config=None,
+                    ray_gcs_external_storage_config=existing_version.ray_gcs_external_storage_config,
+                    tracing_config=existing_version.tracing_config,
+                    version=version_name,
+                    traffic_percent=traffic_percent,
+                )
+            else:
+                service_version = self._build_apply_service_model_for_rollout(
+                    name,
+                    config,
+                    RolloutStrategy.MULTI_VERSION,
+                    existing_service=existing_service,
+                    traffic_percent=traffic_percent,
+                )
+
+            service_versions.append(service_version)
+
+        assert len(service_versions) > 0, "service_versions should not be empty"
+        return ApplyProductionServiceMultiVersionV2Model(
+            rollout_strategy=RolloutStrategy.MULTI_VERSION,
+            cloud_id=cloud_id,
+            project_id=project_id,
+            service_versions=service_versions,
+        )
+
+    def _validate_versions(
+        self, versions: str
+    ) -> List[Dict[str, Any]]:  # noqa: C901, PLR0912
+        # Parse versions JSON string to list of dictionaries
+        try:
+            versions = json.loads(versions)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON format for --versions: {e}")
+
+        for version in versions:
+            # traffic_percent must be specified in all versions by the users.
+            # If some version does not specify traffic_percent, raise an error.
+            if "name" not in version:
+                raise ValueError("Name is required for each version.")
+            if "traffic_percent" not in version:
+                raise ValueError("Traffic percent is required for each version.")
+
+            # Verify the key names are valid. Only either of name, traffic_percent, or capacity_percent are allowed.
+            for key in version:
+                if key not in [
+                    "name",
+                    "traffic_percent",
+                ]:
+                    raise ValueError(f"Invalid key in versions: {key}")
+
+        if isinstance(versions, dict):
+            # Convert object form {"v1": 25, "v2": 75} to full list form
+            versions = [  # type: ignore
+                {"name": name, "traffic_percent": percent}
+                for name, percent in versions.items()
+            ]
+        elif not isinstance(versions, list):
+            raise ValueError(
+                "--versions must be a JSON array of objects or a JSON object in text format."
+            )
+
+        # Verify sum of each traffic_percent from each version is 100.
+        traffic_percent_sum = sum(version["traffic_percent"] for version in versions)
+        if traffic_percent_sum != 100:
+            raise ValueError("Sum of traffic percent for all versions must be 100.")
+
+        return versions  # type: ignore
+
+    def _read_and_validate_configs(
+        self, configs: List[ServiceConfig]
+    ) -> Tuple[str, Optional[str], Optional[str]]:
+        """The service name, cloud, and project must be identical for all versions."""
+
+        # If all the name field from configs are identical, use the first one as the name.
+        # If all the name field from configs are not provided, set to None, use the default name.
+        if all(config.name is None for config in configs):
+            name = self._get_default_name()
+        elif all(config.name == configs[0].name for config in configs):
+            name = configs[0].name
+        else:
+            raise ValueError("All provided names in config files must be identical.")
+
+        # If all the cloud field from configs are identical, use the first one as the cloud.
+        # If all the cloud field from configs are all set to None, set cloud to None. Default cloud will be used from backend.
+        if all(config.cloud is None for config in configs):
+            cloud = None
+        elif all(config.cloud == configs[0].cloud for config in configs):
+            cloud = configs[0].cloud
+        else:
+            raise ValueError("All provided clouds in config files must be identical.")
+
+        # If all the project field from configs are identical, use the first one as the project.
+        # If all the project field from configs are all set to None, set project to None. Default project will be used from backend.
+        if all(config.project is None for config in configs):
+            project = None
+        elif all(config.project == configs[0].project for config in configs):
+            project = configs[0].project
+        else:
+            raise ValueError("All provided projects in config files must be identical.")
+
+        return name, cloud, project
+
+    def _get_service_version_map(
+        self,
+        configs: List[ServiceConfig],
+        versions: Optional[List[Dict[str, Any]]],
+        existing_service: Optional[DecoratedProductionServiceV2APIModel],
+    ) -> Dict[str, Tuple[ServiceConfig, Dict[str, Any]]]:
+        service_config_to_version_config = {}
+        if versions is not None:
+            if len(configs) > len(versions):
+                raise ValueError(
+                    "Number of config files passed must be less than or equal to the number of version configs when multiple versions are being deployed."
+                )
+
+            for service_config in configs:
+                for version_config in versions:
+                    if service_config.version_name == version_config["name"]:
+                        service_config_to_version_config[version_config["name"]] = (
+                            service_config,
+                            version_config,
+                        )
+                        break
+
+                # version name in the ServiceConfig must have a matching version name in the version config.
+                # If this point is reached, then, it means there's a config file passed with version name that doesn't exist in the version config.
+                if service_config.version_name not in service_config_to_version_config:
+                    raise ValueError(
+                        f"version_name {service_config.version_name!r} in service config {service_config} does not match any of the version names provided with --versions."
+                    )
+
+            # version name in version config doesn't need to have a matching version name in service config. If there's not a matching, this
+            # means the version is already deployed, and the user is likely to be only updating the traffic/capacity percent.
+            for version_config in versions:
+                version_name = version_config["name"]
+                if version_name not in service_config_to_version_config:
+                    if existing_service is None:
+                        raise ValueError(
+                            f"--config-file corresponding to version {version_name!r} must be provided if the Service is not already deployed."
+                        )
+                    # TODO(doyoung): Perhaps add a validaiton logic to confirm if the version name already exists in the existing service through existing_service.versions.
+                    service_config_to_version_config[version_name] = (
+                        None,
+                        version_config,
+                    )
+
+        return service_config_to_version_config
+
+    def _get_rollout_strategy(  # noqa: PLR0912
+        self,
+        existing_service: Optional[DecoratedProductionServiceV2APIModel],
+        version_weights: Optional[List[Dict[str, Any]]],
+        in_place: bool,
+        configs: List[ServiceConfig],
+    ) -> RolloutStrategy:
+        """Determine the rollout strategy to use.
+
+        If `in_place` is True, return RolloutStrategy.IN_PLACE.
+        If `version_weights` is None or if the service is going from 0 or 1 versions to 1 version, return RolloutStrategy.ROLLOUT.
+        Otherwise, return RolloutStrategy.MULTI_VERSION.
+        """
+
+        active_versions = len(existing_service.versions) if existing_service else 0
+
+        if in_place:
+            if version_weights is not None:
+                raise ValueError(
+                    "In-place updates are not supported for multi-version services."
+                )
+
+            return RolloutStrategy.IN_PLACE
+        elif version_weights is None or (
+            len(version_weights) == 1 and active_versions <= 1
+        ):
+            if existing_service is None and len(configs) == 0:
+                raise ValueError(
+                    "A config file must be provided when deploying a new service."
+                )
+            if version_weights is not None:
+                self.logger.warning(
+                    "Defaulting to ROLLOUT strategy for single version service. Ignoring --versions."
+                )
+
+            return RolloutStrategy.ROLLOUT
+        else:
+            return RolloutStrategy.MULTI_VERSION
+
+    def deploy(  # noqa: PLR0912, C901
+        self,
+        configs: Union[ServiceConfig, List[ServiceConfig]],
         *,
         in_place: bool = False,
         canary_percent: Optional[int] = None,
         max_surge_percent: Optional[int] = None,
+        versions: Optional[str] = None,
+        name: Optional[str] = None,
+        cloud: Optional[str] = None,
+        project: Optional[str] = None,
     ) -> str:
-        if not isinstance(in_place, bool):
-            raise TypeError("in_place must be a bool.")
+        """Deploy or update a service.
 
-        if canary_percent is not None:
-            if not isinstance(canary_percent, int):
-                raise TypeError("canary_percent must be an int.")
-            if canary_percent < 0 or canary_percent > 100:
-                raise ValueError("canary_percent must be between 0 and 100.")
+        Args:
+            configs: Service configuration(s) to deploy. Can be a single ServiceConfig or a list of ServiceConfig objects for multi-version deployments.
+            versions: JSON string specifying version configurations for multi-version deployments.
+            name: Name of the service. If not provided, defaults to workspace cluster name.
+            cloud: Cloud provider to deploy to.
+            project: Project to deploy the service in.
 
-        if max_surge_percent is not None:
-            if not isinstance(max_surge_percent, int):
-                raise TypeError("max_surge_percent must be an int.")
-            if max_surge_percent < 0 or max_surge_percent > 100:
-                raise ValueError("max_surge_percent must be between 0 and 100.")
+        Returns:
+            The service ID.
+        """
+        if versions is not None:
+            versions = self._validate_versions(versions)  # type: ignore
 
-        name = config.name or self._get_default_name()
-        existing_service: Optional[DecoratedProductionServiceV2APIModel] = (
-            self.client.get_service(
-                name=name, cloud=config.cloud, project=config.project
+        if isinstance(configs, ServiceConfig):
+            if versions is not None:
+                raise ValueError(
+                    "To deploy with --versions, a list of ServiceConfig must be provided."
+                )
+
+            if not isinstance(in_place, bool):
+                raise TypeError("in_place must be a bool.")
+
+            if canary_percent is not None:
+                if not isinstance(canary_percent, int):
+                    raise TypeError("canary_percent must be an int.")
+                if canary_percent < 0 or canary_percent > 100:
+                    raise ValueError("canary_percent must be between 0 and 100.")
+
+            if max_surge_percent is not None:
+                if not isinstance(max_surge_percent, int):
+                    raise TypeError("max_surge_percent must be an int.")
+                if max_surge_percent < 0 or max_surge_percent > 100:
+                    raise ValueError("max_surge_percent must be between 0 and 100.")
+
+            name = configs.name
+            cloud = configs.cloud
+            project = configs.project
+            configs = [configs]
+
+        elif isinstance(configs, List):
+            if versions is None:
+                raise ValueError(
+                    "--versions must be provided when deploying with multiple config files."
+                )
+
+            if len(configs) == 0:
+                if name is None:
+                    raise ValueError(
+                        "When using --versions, a service name must be provided if no config files are given."
+                    )
+            else:
+                name, cloud, project = self._read_and_validate_configs(configs)
+
+        else:
+            ValueError(
+                "Single object of ServiceConfig or list of ServiceConfig must be provided."
             )
+
+        if name is None:
+            name = self._get_default_name()
+
+        existing_service: Optional[DecoratedProductionServiceV2APIModel] = (
+            self.client.get_service(name=name, cloud=cloud, project=project)
         )
         if existing_service is None:
             self.logger.info(f"Starting new service '{name}'.")
@@ -451,37 +751,63 @@ class PrivateServiceSDK(WorkloadSDK):
         else:
             self.logger.info(f"Updating existing service '{name}'.")
 
-        # passed canary_percent is ignored when creating or restarting a service
+        # passed canary_percent is ignored when creating or restarting a service or multiple versions are being deployed.
         is_new_or_restarting = (
             existing_service is None
             or existing_service.current_state == ServiceEventCurrentState.TERMINATED
         )
-        if canary_percent is not None and is_new_or_restarting:
+        if canary_percent is not None and (
+            is_new_or_restarting or versions is not None
+        ):
             canary_percent = None
             self.logger.warning(
-                "canary_percent is ignored when creating or restarting a service."
+                "canary_percent is ignored when creating or restarting a service or multiple versions are being deployed."
             )
 
-        if in_place:
+        rollout_strategy = self._get_rollout_strategy(
+            existing_service, versions, in_place, configs  # type: ignore
+        )
+
+        service: DecoratedProductionServiceV2APIModel
+        # TODO(doyoung): Support multi version deployment for in_place update.
+        if rollout_strategy == RolloutStrategy.IN_PLACE:
+            if versions is not None:
+                raise ValueError(
+                    "versions cannot be specified when doing an in_place update."
+                )
+            assert len(configs) == 1
             model = self._build_apply_service_model_for_in_place_update(
                 name,
-                config,
+                configs[0],
                 canary_percent=canary_percent,
                 max_surge_percent=max_surge_percent,
                 existing_service=existing_service,
             )
+            service = self.client.rollout_service(model)
+        elif rollout_strategy == RolloutStrategy.MULTI_VERSION:
+            model = self._build_apply_service_model_for_multi_version(
+                name,
+                cloud,
+                project,
+                configs,
+                existing_service=existing_service,
+                versions=versions,  # type: ignore
+            )
+            service = self.client.rollout_service_multi_version(model)
         else:
+            # rolling out a single version in new service without specifying versions.
+            assert len(configs) == 1
             model = self._build_apply_service_model_for_rollout(
                 name,
-                config,
+                configs[0],
+                RolloutStrategy.ROLLOUT,
                 canary_percent=canary_percent,
                 max_surge_percent=max_surge_percent,
                 existing_service=existing_service,
             )
+            service = self.client.rollout_service(model)
 
-        service = self.client.rollout_service(model)
         self._log_deployed_service_info(service, canary_percent=canary_percent)
-
         return service.id
 
     def _resolve_to_service_model(

anyscale/service/commands.py

@@ -32,10 +32,14 @@ anyscale.service.deploy(
 """
 
 _DEPLOY_ARG_DOCSTRINGS = {
-    "config": "The config options defining the service.",
+    "configs": "The config options defining the service.",
     "in_place": "Perform an in-place upgrade without starting a new cluster. This can be used for faster iteration during development but is *not* currently recommended for production deploys. This *cannot* be used to change cluster-level options such as image and compute config (they will be ignored).",
     "canary_percent": "The percentage of traffic to send to the canary version of the service (0-100). This can be used to manually shift traffic toward (or away from) the canary version. If not provided, traffic will be shifted incrementally toward the canary version until it reaches 100. Not supported when using --in-place. This is ignored when restarting a service or creating a new service.",
     "max_surge_percent": "Amount of excess capacity allowed to be used while updating the service (0-100). Defaults to 100. Not supported when using --in-place.",
+    "versions": "Enable multi-version deployment by providing a JSON array of objects or a JSON object in text format. Defines the version name, traffic and capacity percents per version. Capacity defaults to traffic.",
+    "name": "Name of the service. When running in a workspace, this defaults to the workspace name.",
+    "cloud": "The Anyscale Cloud of this workload. If not provided, the organization default will be used (or, if running in a workspace, the cloud of the workspace).",
+    "project": "Named project to use for the service. If not provided, the default project for the cloud will be used (or, if running in a workspace, the project of the workspace).",
 }
 
 
@@ -46,11 +50,15 @@ _DEPLOY_ARG_DOCSTRINGS = {
     arg_docstrings=_DEPLOY_ARG_DOCSTRINGS,
 )
 def deploy(
-    config: ServiceConfig,
+    configs: Union[ServiceConfig, List[ServiceConfig]],
     *,
     in_place: bool = False,
     canary_percent: Optional[int] = None,
     max_surge_percent: Optional[int] = None,
+    versions: Optional[str] = None,
+    name: Optional[str] = None,
+    cloud: Optional[str] = None,
+    project: Optional[str] = None,
     _private_sdk: Optional[PrivateServiceSDK] = None,
 ) -> str:
     """Deploy a service.
@@ -62,10 +70,14 @@ def deploy(
     Returns the id of the deployed service.
     """
     return _private_sdk.deploy(  # type: ignore
-        config,
+        configs=configs,
         in_place=in_place,
         canary_percent=canary_percent,
         max_surge_percent=max_surge_percent,
+        versions=versions,
+        name=name,
+        cloud=cloud,
+        project=project,
     )
 
 

anyscale/service/models.py

@@ -231,6 +231,18 @@ tracing_config: # (Optional) Configuration options for tracing.
         },
     )
 
+    version_name: Optional[str] = field(
+        default=None, metadata={"docstring": "Unique name of the version."},
+    )
+
+    def _validate_version_name(self, version_name: Optional[str]):
+        # Allow None if optional; enforce non-empty string if required
+        if version_name is None:
+            return None
+        if not isinstance(version_name, str) or not version_name.strip():
+            raise ValueError("version_name must be a non-empty string")
+        return version_name
+
     def _validate_applications(self, applications: List[Dict[str, Any]]):
         if not isinstance(applications, list):
             raise TypeError("'applications' must be a list.")

anyscale/shared_anyscale_utils/latest_ray_version.py

@@ -1,3 +1,3 @@
 # AUTOGENERATED - modify shared_anyscale_util in root directory to make changes
 # RAY_RELEASE_UPDATE: managed by release automation.
-LATEST_RAY_VERSION = "2.50.0"
+LATEST_RAY_VERSION = "2.50.1"

anyscale/version.py

@@ -1 +1 @@
-__version__ = "0.26.68"
+__version__ = "0.26.70"

{anyscale-0.26.68.dist-info → anyscale-0.26.70.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anyscale
-Version: 0.26.68
+Version: 0.26.70
 Summary: Command Line Interface for Anyscale
 Author: Anyscale Inc.
 License: AS License