Merge branch 'main' into fix_operators_copytree

Author: mrDzurb

CODEOWNERS

@@ -1 +1 @@
-* @darenr @mayoor @mrDzurb @VipulMascarenhas @qiuosier @ahosler
+* @mayoor @mrDzurb @VipulMascarenhas @lu-ohai @smfirmin @sambitkumohanty

ads/common/utils.py

@@ -237,6 +237,31 @@ def parse_bool(value: Any) -> bool:
     return bool(value)
 
 
+def parse_int(value: Any, default: Optional[int] = None) -> Optional[int]:
+    """Converts a value to int.
+
+    Parameters
+    ----------
+    value: Any
+        The value to convert.
+    default: Optional[int]
+        The value to return if `value` is None.
+
+    Returns
+    -------
+    Optional[int]
+        The int value or `default`.
+
+    Raises
+    ------
+    ValueError
+        If `value` cannot be converted to int.
+    """
+    if value is None:
+        return default
+    return int(value)
+
+
 def read_file(file_path: str, **kwargs) -> str:
     try:
         with fsspec.open(file_path, "r", **kwargs.get("auth", {})) as f:

ads/model/datascience_model_group.py

@@ -1,14 +1,17 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2025 Oracle and/or its affiliates.
+# Copyright (c) 2025, 2026 Oracle and/or its affiliates.
 # Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl/
 
 import copy
+import logging
+import os
 from typing import Dict, List, Union
 
 from ads.common.utils import batch_convert_case
 from ads.config import COMPARTMENT_OCID, PROJECT_OCID
 from ads.jobs.builders.base import Builder
+from ads.model.artifact import _validate_artifact_dir
 from ads.model.model_metadata import ModelCustomMetadata
 from ads.model.service.oci_datascience_model_group import OCIDataScienceModelGroup
 
@@ -36,6 +39,16 @@
 ALLOWED_CREATE_TYPES = ["CREATE", "CLONE"]
 MODEL_GROUP_KIND = "datascienceModelGroup"
 
+logger = logging.getLogger(__name__)
+
+
+class ModelGroupArtifactNotFoundError(Exception):  # pragma: no cover
+    pass
+
+
+class ModelGroupArtifactValidationError(ValueError):  # pragma: no cover
+    pass
+
 
 class DataScienceModelGroup(Builder):
     """Represents a Data Science Model Group.
@@ -153,6 +166,7 @@ class DataScienceModelGroup(Builder):
     CONST_CREATED_BY = "createdBy"
     CONST_VERSION_LABEL = "versionLabel"
     CONST_VERSION_ID = "versionId"
+    CONST_ARTIFACT = "artifact"
 
     attribute_map = {
         CONST_ID: "id",
@@ -201,6 +215,28 @@ def __init__(self, spec=None, **kwargs):
         super().__init__(spec, **kwargs)
         self.dsc_model_group = OCIDataScienceModelGroup()
 
+    @property
+    def artifact(self) -> str:
+        """The artifact location (path to a folder or zip archive).
+
+        For homogeneous model groups this artifact is expected to be a standard
+        model deployment runtime artifact containing (at minimum) `score.py` and
+        `runtime.yaml` at the top level.
+        """
+
+        return self.get_spec(self.CONST_ARTIFACT)
+
+    def with_artifact(self, uri: str) -> "DataScienceModelGroup":
+        """Sets the model group artifact location.
+
+        Parameters
+        ----------
+        uri: str
+            Path to artifact directory or to the ZIP archive.
+        """
+
+        return self.set_spec(self.CONST_ARTIFACT, uri)
+
     @property
     def kind(self) -> str:
         """The kind of the model group as showing in a YAML."""
@@ -508,7 +544,61 @@ def create(
             poll_interval=poll_interval,
         )
 
-        return self._update_from_oci_model(response)
+        self._update_from_oci_model(response)
+
+        # Upload artifact for homogeneous groups only.
+        if not self.base_model_id and self.artifact:
+            self.upload_artifact()
+
+        return self
+
+    def upload_artifact(self) -> None:
+        """Validates and uploads model group artifact.
+
+        Notes
+        -----
+        This currently supports homogeneous model groups only.
+        """
+
+        if not self.id:
+            raise ValueError(
+                "Model group needs to be created before uploading artifacts."
+            )
+
+        if not self.artifact:
+            logger.info(
+                "Model group artifact location not provided. "
+                "Use `.with_artifact(<path>)` to upload a deployment runtime artifact."
+            )
+            return
+
+        artifact_path = os.path.abspath(os.path.expanduser(str(self.artifact)))
+
+        if not os.path.exists(artifact_path):
+            raise ModelGroupArtifactNotFoundError(
+                f"The artifact path `{self.artifact}` does not exist."
+            )
+
+        # Validate expected runtime artifact structure when artifact is a directory.
+        if os.path.isdir(artifact_path):
+            try:
+                _validate_artifact_dir(artifact_path)
+            except Exception as ex:
+                raise ModelGroupArtifactValidationError(
+                    f"Invalid model group artifact directory structure at `{artifact_path}`. "
+                    f"Expected top-level `score.py` and `runtime.yaml`. See: {ex}"
+                ) from ex
+
+        # Perform upload. Implemented in OCIDataScienceModelGroup.
+        try:
+            self.dsc_model_group = OCIDataScienceModelGroup.from_id(self.id)
+            self.dsc_model_group.create_model_group_artifact(artifact_path)
+            logger.info("Model group artifact upload succeeded.")
+        except AttributeError as ex:
+            raise RuntimeError(
+                "Model group artifact upload requires an OCI SDK that supports "
+                f"`create_model_group_artifact`. Please upgrade `oci` package. See: {ex}"
+            ) from ex
 
     def _build_model_group_details(self) -> dict:
         """Builds model group details dict for creating or updating oci model group."""
@@ -544,6 +634,7 @@ def _build_model_group_details(self) -> dict:
         build_model_group_details.pop(self.CONST_CUSTOM_METADATA_LIST, None)
         build_model_group_details.pop(self.CONST_MEMBER_MODELS, None)
         build_model_group_details.pop(self.CONST_BASE_MODEL_ID, None)
+        build_model_group_details.pop(self.CONST_ARTIFACT, None)
         build_model_group_details.update(
             {
                 self.CONST_COMPARTMENT_ID: self.compartment_id or COMPARTMENT_OCID,

ads/model/deployment/model_deployment.py

@@ -1717,11 +1717,68 @@ def _build_model_deployment_configuration_details(self) -> Dict:
                 infrastructure.capacity_reservation_ids
             )
 
-        scaling_policy = {
-            infrastructure.CONST_POLICY_TYPE: "FIXED_SIZE",
-            infrastructure.CONST_INSTANCE_COUNT: infrastructure.replica
-            or DEFAULT_REPLICA,
-        }
+        def _drop_none_values(d: Dict) -> Dict:
+            """Drops keys with None values from the provided dict."""
+            return {k: v for k, v in d.items() if v is not None}
+
+        # Fixed-size is the default. If autoscaling is configured on infrastructure,
+        # emit an AUTOSCALING policy (supported for both SINGLE_MODEL and MODEL_GROUP).
+        auto_scaling = getattr(infrastructure, "auto_scaling", None) or {}
+        if auto_scaling:
+            scaling_type = str(auto_scaling.get("scalingType", "") or "").lower()
+            metric_type = scaling_type.upper()
+
+            scaling_policy = {
+                infrastructure.CONST_POLICY_TYPE: "AUTOSCALING",
+                "isEnabled": auto_scaling.get("isEnabled", True),
+                "coolDownInSeconds": auto_scaling.get("coolDownInSeconds", None),
+                "autoScalingPolicies": [
+                    _drop_none_values(
+                        {
+                            "autoScalingPolicyType": "THRESHOLD",
+                            "maximumInstanceCount": auto_scaling.get(
+                                "maximumInstanceCount", 3
+                            ),
+                            "minimumInstanceCount": auto_scaling.get(
+                                "minimumInstanceCount", 1
+                            ),
+                            "initialInstanceCount": auto_scaling.get(
+                                "initialInstanceCount",
+                                infrastructure.replica or DEFAULT_REPLICA,
+                            ),
+                            "rules": [
+                                {
+                                    "metricExpressionRuleType": "PREDEFINED_EXPRESSION",
+                                    "metricType": metric_type,
+                                    "scaleInConfiguration": _drop_none_values(
+                                        {
+                                            "scalingConfigurationType": "THRESHOLD",
+                                            "threshold": auto_scaling.get(
+                                                "scaleInThreshold", 30
+                                            ),
+                                        }
+                                    ),
+                                    "scaleOutConfiguration": _drop_none_values(
+                                        {
+                                            "scalingConfigurationType": "THRESHOLD",
+                                            "threshold": auto_scaling.get(
+                                                "scaleOutThreshold", 70
+                                            ),
+                                        }
+                                    ),
+                                }
+                            ],
+                        }
+                    )
+                ],
+            }
+            scaling_policy = _drop_none_values(scaling_policy)
+        else:
+            scaling_policy = {
+                infrastructure.CONST_POLICY_TYPE: "FIXED_SIZE",
+                infrastructure.CONST_INSTANCE_COUNT: infrastructure.replica
+                or DEFAULT_REPLICA,
+            }
 
         if not (runtime.model_uri or runtime.model_group_id):
             raise ValueError(

ads/model/deployment/model_deployment_infrastructure.py

@@ -155,6 +155,26 @@ class ModelDeploymentInfrastructure(Builder):
     CONST_PRIVATE_ENDPOINT_ID = "privateEndpointId"
     CONST_CAPACITY_RESERVATION_IDS = "capacityReservationIds"
 
+    # Autoscaling config (builder-only; used when constructing `scalingPolicy` payload).
+    # This can be applied to both SINGLE_MODEL and MODEL_GROUP deployments.
+    CONST_AUTO_SCALING = "autoScaling"
+    CONST_SCALING_TYPE = "scalingType"
+    CONST_MINIMUM_INSTANCE_COUNT = "minimumInstanceCount"
+    CONST_MAXIMUM_INSTANCE_COUNT = "maximumInstanceCount"
+    CONST_INITIAL_INSTANCE_COUNT = "initialInstanceCount"
+    CONST_SCALE_IN_THRESHOLD = "scaleInThreshold"
+    CONST_SCALE_OUT_THRESHOLD = "scaleOutThreshold"
+    CONST_COOL_DOWN_IN_SECONDS = "coolDownInSeconds"
+    CONST_IS_ENABLED = "isEnabled"
+
+    # Autoscaling constants (for `with_auto_scaling`).
+    CONST_SCALING_TYPE_CPU_UTILIZATION = "cpu_utilization"
+    CONST_SCALING_TYPE_MEMORY_UTILIZATION = "memory_utilization"
+    CONST_SUPPORTED_AUTO_SCALING_TYPES = (
+        CONST_SCALING_TYPE_CPU_UTILIZATION,
+        CONST_SCALING_TYPE_MEMORY_UTILIZATION,
+    )
+
     attribute_map = {
         CONST_PROJECT_ID: "project_id",
         CONST_COMPARTMENT_ID: "compartment_id",
@@ -172,6 +192,7 @@ class ModelDeploymentInfrastructure(Builder):
         CONST_SUBNET_ID: "subnet_id",
         CONST_PRIVATE_ENDPOINT_ID: "private_endpoint_id",
         CONST_CAPACITY_RESERVATION_IDS: "capacity_reservation_ids",
+        CONST_AUTO_SCALING: "auto_scaling",
     }
 
     shape_config_details_attribute_map = {
@@ -720,6 +741,83 @@ def with_capacity_reservation_ids(
             self.CONST_CAPACITY_RESERVATION_IDS, capacity_reservation_ids
         )
 
+    @property
+    def auto_scaling(self) -> Dict:
+        """Autoscaling configuration for model deployment.
+
+        This configuration is used when building the deployment payload to generate
+        an `AUTOSCALING` scaling policy.
+
+        Returns
+        -------
+        Dict
+            Autoscaling configuration.
+        """
+        return self.get_spec(self.CONST_AUTO_SCALING, {})
+
+    def with_auto_scaling(
+        self,
+        scaling_type: str,
+        minimum_instance_count: int = 1,
+        maximum_instance_count: int = 3,
+        initial_instance_count: int = None,
+        scale_in_threshold: int = 30,
+        scale_out_threshold: int = 70,
+        cool_down_in_seconds: int = None,
+        is_enabled: bool = True,
+    ) -> "ModelDeploymentInfrastructure":
+        """Enables threshold-based autoscaling.
+
+        Parameters
+        ----------
+        scaling_type: str
+            One of ["cpu_utilization", "memory_utilization"].
+        minimum_instance_count: int
+            Minimum number of instances (default: 1).
+        maximum_instance_count: int
+            Maximum number of instances (default: 3).
+        initial_instance_count: int
+            Initial number of instances.
+            Defaults to `replica` if set, otherwise `minimum_instance_count`.
+        scale_in_threshold: int
+            Threshold for scaling in (default: 30).
+        scale_out_threshold: int
+            Threshold for scaling out (default: 70).
+        cool_down_in_seconds: int
+            Optional cooldown period.
+        is_enabled: bool
+            Whether autoscaling is enabled (default: True).
+
+        Returns
+        -------
+        ModelDeploymentInfrastructure
+            The ModelDeploymentInfrastructure instance (self).
+        """
+        scaling_type = str(scaling_type or "").lower()
+        if scaling_type not in self.CONST_SUPPORTED_AUTO_SCALING_TYPES:
+            raise ValueError(
+                "Invalid scaling_type: {}. Allowed values: {}.".format(
+                    scaling_type, list(self.CONST_SUPPORTED_AUTO_SCALING_TYPES)
+                )
+            )
+
+        if initial_instance_count is None:
+            initial_instance_count = self.replica or minimum_instance_count
+
+        config = {
+            self.CONST_SCALING_TYPE: scaling_type,
+            self.CONST_MINIMUM_INSTANCE_COUNT: minimum_instance_count,
+            self.CONST_MAXIMUM_INSTANCE_COUNT: maximum_instance_count,
+            self.CONST_INITIAL_INSTANCE_COUNT: initial_instance_count,
+            self.CONST_SCALE_IN_THRESHOLD: scale_in_threshold,
+            self.CONST_SCALE_OUT_THRESHOLD: scale_out_threshold,
+            self.CONST_IS_ENABLED: bool(is_enabled),
+        }
+        if cool_down_in_seconds is not None:
+            config[self.CONST_COOL_DOWN_IN_SECONDS] = cool_down_in_seconds
+
+        return self.set_spec(self.CONST_AUTO_SCALING, config)
+
     def init(self, **kwargs) -> "ModelDeploymentInfrastructure":
         """Initializes a starter specification for the ModelDeploymentInfrastructure.