Merge branch 'main' into python_3_13

Author: mrDzurb

.github/workflows/run-forecast-explainer-tests.yml

@@ -54,6 +54,6 @@ jobs:
           $CONDA/bin/conda init
           source /home/runner/.bashrc
           pip install -r test-requirements-operators.txt
-          pip install "oracle-automlx[forecasting]>=25.1.1"
+          pip install "oracle-automlx[forecasting]>=25.3.0"
           pip install pandas>=2.2.0
           python -m pytest -v -p no:warnings --durations=5 tests/operators/forecast/test_explainers.py

.github/workflows/run-forecast-unit-tests.yml

@@ -56,6 +56,6 @@ jobs:
           $CONDA/bin/conda init
           source /home/runner/.bashrc
           pip install -r test-requirements-operators.txt
-          pip install "oracle-automlx[forecasting]>=25.1.1"
+          pip install "oracle-automlx[forecasting]>=25.3.0"
           pip install pandas>=2.2.0
           python -m pytest -v -p no:warnings --durations=5 tests/operators/forecast --ignore=tests/operators/forecast/test_explainers.py

ads/aqua/client/client.py

@@ -582,6 +582,19 @@ def embeddings(
         payload = {**(payload or {}), "input": input}
         return self._request(payload=payload, headers=headers)
 
+    def fetch_data(self) -> Union[Dict[str, Any], Iterator[Mapping[str, Any]]]:
+        """Fetch Data in json format by sending a request to the endpoint.
+
+        Args:
+
+        Returns:
+            Union[Dict[str, Any], Iterator[Mapping[str, Any]]]: The server's response, typically including the data in JSON format.
+        """
+        # headers = {"Content-Type", "application/json"}
+        response = self._client.get(self.endpoint)
+        json_response = response.json()
+        return json_response
+
 
 class AsyncClient(BaseClient):
     """

ads/aqua/common/enums.py

@@ -58,6 +58,7 @@ class InferenceContainerTypeFamily(ExtendedEnum):
     AQUA_VLLM_LLAMA4_CONTAINER_FAMILY = "odsc-vllm-serving-llama4"
     AQUA_TGI_CONTAINER_FAMILY = "odsc-tgi-serving"
     AQUA_LLAMA_CPP_CONTAINER_FAMILY = "odsc-llama-cpp-serving"
+    AQUA_VLLM_OPENAI_CONTAINER_FAMILY = "odsc-vllm-serving-openai"
 
 
 class CustomInferenceContainerTypeFamily(ExtendedEnum):

ads/aqua/common/utils.py

@@ -997,6 +997,44 @@ def get_container_params_type(container_type_name: str) -> str:
         return UNKNOWN
 
 
+def get_container_env_type(container_type_name: Optional[str]) -> str:
+    """
+    Determine the container environment type based on the container type name.
+
+    This function matches the provided container type name against the known
+    values of `InferenceContainerType`. The check is case-insensitive and
+    allows for partial matches so that changes in container naming conventions
+    (e.g., prefixes or suffixes) will still be matched correctly.
+
+    Examples:
+        >>> get_container_env_type("odsc-vllm-serving")
+        'vllm'
+        >>> get_container_env_type("ODSC-TGI-Serving")
+        'tgi'
+        >>> get_container_env_type("custom-unknown-container")
+        'UNKNOWN'
+
+    Args:
+        container_type_name (Optional[str]):
+            The deployment container type name (e.g., "odsc-vllm-serving").
+
+    Returns:
+        str:
+            - A matching `InferenceContainerType` value string (e.g., "VLLM", "TGI", "LLAMA-CPP").
+            - `"UNKNOWN"` if no match is found or the input is empty/None.
+    """
+    if not container_type_name:
+        return UNKNOWN
+
+    needle = container_type_name.strip().casefold()
+
+    for container_type in InferenceContainerType.values():
+        if container_type and container_type.casefold() in needle:
+            return container_type.upper()
+
+    return UNKNOWN
+
+
 def get_restricted_params_by_container(container_type_name: str) -> set:
     """The utility function accepts the deployment container type name and returns a set of restricted params
         for that container.

ads/aqua/config/container_config.py

@@ -191,21 +191,28 @@ def from_service_config(
                     additional_configurations.get("modelFormats")
                 )
 
-                # Parse environment variables from `additional_configurations`.
-                # Only keys present in the configuration will be added to the result.
-                config_keys = {
-                    "MODEL_DEPLOY_PREDICT_ENDPOINT": UNKNOWN,
-                    "MODEL_DEPLOY_HEALTH_ENDPOINT": UNKNOWN,
-                    "PORT": UNKNOWN,
-                    "HEALTH_CHECK_PORT": UNKNOWN,
-                    "VLLM_USE_V1": UNKNOWN,
-                }
-
-                env_vars = [
-                    {key: additional_configurations.get(key, default)}
-                    for key, default in config_keys.items()
-                    if key in additional_configurations
-                ]
+                # TODO: Remove the else condition once SMC env variable config is updated everywhere
+                if additional_configurations.get("env_vars", None):
+                    env_vars_dict = json.loads(
+                        additional_configurations.get("env_vars") or "{}"
+                    )
+                    env_vars = [
+                        {key: str(value)} for key, value in env_vars_dict.items()
+                    ]
+                else:
+                    config_keys = {
+                        "MODEL_DEPLOY_PREDICT_ENDPOINT": UNKNOWN,
+                        "MODEL_DEPLOY_HEALTH_ENDPOINT": UNKNOWN,
+                        "PORT": UNKNOWN,
+                        "HEALTH_CHECK_PORT": UNKNOWN,
+                        "VLLM_USE_V1": UNKNOWN,
+                    }
+
+                    env_vars = [
+                        {key: additional_configurations.get(key, default)}
+                        for key, default in config_keys.items()
+                        if key in additional_configurations
+                    ]
 
                 # Build container spec
                 container_item.spec = AquaContainerConfigSpec(

ads/aqua/extension/deployment_handler.py

@@ -373,6 +373,37 @@ def post(self, *args, **kwargs):  # noqa: ARG002
         )
 
 
+class AquaModelListHandler(AquaAPIhandler):
+    """Handler for Aqua model list params REST APIs.
+
+    Methods
+    -------
+    get(self, *args, **kwargs)
+        Validates parameters for the given model id.
+    """
+
+    @handle_exceptions
+    def get(self, model_deployment_id):
+        """
+        Handles get model list for the Active Model Deployment
+        Raises
+        ------
+        HTTPError
+            Raises HTTPError if inputs are missing or are invalid
+        """
+
+        self.set_header("Content-Type", "application/json")
+        endpoint: str = ""
+        model_deployment = AquaDeploymentApp().get(model_deployment_id)
+        endpoint = model_deployment.endpoint.rstrip("/") + "/predict/v1/models"
+        aqua_client = Client(endpoint=endpoint)
+        try:
+            list_model_result = aqua_client.fetch_data()
+            return self.finish(list_model_result)
+        except Exception as ex:
+            raise HTTPError(500, str(ex))
+
+
 __handlers__ = [
     ("deployments/?([^/]*)/params", AquaDeploymentParamsHandler),
     ("deployments/config/?([^/]*)", AquaDeploymentHandler),
@@ -381,4 +412,5 @@ def post(self, *args, **kwargs):  # noqa: ARG002
     ("deployments/?([^/]*)/activate", AquaDeploymentHandler),
     ("deployments/?([^/]*)/deactivate", AquaDeploymentHandler),
     ("inference/stream/?([^/]*)", AquaDeploymentStreamingInferenceHandler),
+    ("deployments/models/list/?([^/]*)", AquaModelListHandler),
 ]

ads/aqua/modeldeployment/config_loader.py

@@ -88,6 +88,7 @@ class MultiModelConfig(Serializable):
         gpu_count (int, optional): Number of GPUs count to this model of this shape.
         parameters (Dict[str, str], optional): A dictionary of parameters (e.g., VLLM_PARAMS) to
             configure the behavior of a particular GPU shape.
+        env (Dict[str, Dict[str, str]]): Environment variables grouped by namespace (e.g., "VLLM": {"VAR": "VAL"}).
     """
 
     gpu_count: Optional[int] = Field(
@@ -97,6 +98,10 @@ class MultiModelConfig(Serializable):
         default_factory=dict,
         description="Key-value pairs for GPU shape parameters (e.g., VLLM_PARAMS).",
     )
+    env: Optional[Dict[str, Dict[str, str]]] = Field(
+        default_factory=dict,
+        description="Environment variables grouped by namespace",
+    )
 
     class Config:
         extra = "allow"
@@ -130,6 +135,7 @@ class ConfigurationItem(Serializable):
             configure the behavior of a particular GPU shape.
         multi_model_deployment (List[MultiModelConfig], optional): A list of multi model configuration details.
         shape_info (DeploymentShapeInfo, optional): The shape information to this model for specific CPU shape.
+        env (Dict[str, Dict[str, str]]): Environment variables grouped by namespace (e.g., "VLLM": {"VAR": "VAL"}).
     """
 
     parameters: Optional[Dict[str, str]] = Field(
@@ -143,6 +149,10 @@ class ConfigurationItem(Serializable):
         default_factory=DeploymentShapeInfo,
         description="The shape information to this model for specific shape",
     )
+    env: Optional[Dict[str, Dict[str, str]]] = Field(
+        default_factory=dict,
+        description="Environment variables grouped by namespace",
+    )
 
     class Config:
         extra = "allow"

ads/aqua/modeldeployment/deployment.py

@@ -27,6 +27,7 @@
     build_pydantic_error_message,
     find_restricted_params,
     get_combined_params,
+    get_container_env_type,
     get_container_params_type,
     get_ocid_substring,
     get_params_list,
@@ -199,7 +200,7 @@ def create(
         if create_deployment_details.instance_shape.lower() not in available_shapes:
             raise AquaValueError(
                 f"Invalid Instance Shape. The selected shape '{create_deployment_details.instance_shape}' "
-                f"is not available in the {self.region} region. Please choose another shape to deploy the model."
+                f"is not supported in the {self.region} region. Please choose another shape to deploy the model."
             )
 
         # Get container config
@@ -381,6 +382,7 @@ def _create(
             Tags.AQUA_SERVICE_MODEL_TAG,
             Tags.AQUA_FINE_TUNED_MODEL_TAG,
             Tags.AQUA_TAG,
+            Tags.BASE_MODEL_CUSTOM,
         ]:
             if tag in aqua_model.freeform_tags:
                 tags[tag] = aqua_model.freeform_tags[tag]
@@ -1042,6 +1044,7 @@ def get_deployment_config(self, model_id: str) -> AquaDeploymentConfig:
         config = self.get_config_from_metadata(
             model_id, AquaModelMetadataKeys.DEPLOYMENT_CONFIGURATION
         ).config
+
         if config:
             logger.info(
                 f"Fetched {AquaModelMetadataKeys.DEPLOYMENT_CONFIGURATION} from defined metadata for model: {model_id}."
@@ -1126,7 +1129,7 @@ def get_deployment_default_params(
         model_id: str,
         instance_shape: str,
         gpu_count: int = None,
-    ) -> List[str]:
+    ) -> Dict:
         """Gets the default params set in the deployment configs for the given model and instance shape.
 
         Parameters
@@ -1148,6 +1151,7 @@ def get_deployment_default_params(
 
         """
         default_params = []
+        default_envs = {}
         config_params = {}
         model = DataScienceModel.from_id(model_id)
         try:
@@ -1157,19 +1161,15 @@ def get_deployment_default_params(
         except ValueError:
             container_type_key = UNKNOWN
             logger.debug(
-                f"{AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} key is not available in the custom metadata field for model {model_id}."
+                f"{AQUA_DEPLOYMENT_CONTAINER_METADATA_NAME} key is not available in the "
+                f"custom metadata field for model {model_id}."
             )
 
-        if (
-            container_type_key
-            and container_type_key in InferenceContainerTypeFamily.values()
-        ):
+        if container_type_key:
             deployment_config = self.get_deployment_config(model_id)
-
             instance_shape_config = deployment_config.configuration.get(
                 instance_shape, ConfigurationItem()
             )
-
             if instance_shape_config.multi_model_deployment and gpu_count:
                 gpu_params = instance_shape_config.multi_model_deployment
 
@@ -1178,12 +1178,18 @@ def get_deployment_default_params(
                         config_params = gpu_config.parameters.get(
                             get_container_params_type(container_type_key), UNKNOWN
                         )
+                        default_envs = instance_shape_config.env.get(
+                            get_container_env_type(container_type_key), {}
+                        )
                         break
 
             else:
                 config_params = instance_shape_config.parameters.get(
                     get_container_params_type(container_type_key), UNKNOWN
                 )
+                default_envs = instance_shape_config.env.get(
+                    get_container_env_type(container_type_key), {}
+                )
 
             if config_params:
                 params_list = get_params_list(config_params)
@@ -1196,7 +1202,7 @@ def get_deployment_default_params(
                     if params.split()[0] not in restricted_params_set:
                         default_params.append(params)
 
-        return default_params
+        return {"data": default_params, "env": default_envs}
 
     def validate_deployment_params(
         self,

ads/aqua/modeldeployment/entities.py

@@ -233,6 +233,7 @@ class CreateModelDeploymentDetails(BaseModel):
         None, description="The description of the deployment."
     )
     model_id: Optional[str] = Field(None, description="The model OCID to deploy.")
+
     models: Optional[List[AquaMultiModelRef]] = Field(
         None, description="List of models for multimodel deployment."
     )