zenml-nightly 0.62.0.dev20240717__tar.gz → 0.62.0.dev20240720__tar.gz

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zenml-nightly
-Version: 0.62.0.dev20240717
+Version: 0.62.0.dev20240720
 Summary: ZenML: Write production-ready ML code.
 Home-page: https://zenml.io
 License: Apache-2.0

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zenml-nightly"
-version = "0.62.0.dev20240717"
+version = "0.62.0.dev20240720"
 packages = [{ include = "zenml", from = "src" }]
 description = "ZenML: Write production-ready ML code."
 authors = ["ZenML GmbH <info@zenml.io>"]

zenml_nightly-0.62.0.dev20240720/src/zenml/VERSION

@@ -0,0 +1 @@
+0.62.0.dev20240720

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/cli/stack.py

@@ -491,18 +491,6 @@ def register_stack(
                 artifact_store = component_name
             if component_type == StackComponentType.ORCHESTRATOR:
                 orchestrator = component_name
-                if not isinstance(
-                    component_info, UUID
-                ) and component_info.flavor.startswith("vm"):
-                    if isinstance(
-                        service_connector, ServiceConnectorInfo
-                    ) and service_connector.auth_method in {
-                        "service-account",
-                        "external-account",
-                    }:
-                        service_connector.configuration[
-                            "generate_temporary_tokens"
-                        ] = False
             if component_type == StackComponentType.CONTAINER_REGISTRY:
                 container_registry = component_name
 
@@ -2316,7 +2304,7 @@ def _get_service_connector_info(
     """
     from rich.prompt import Prompt
 
-    if cloud_provider not in {"aws", "gcp"}:
+    if cloud_provider not in {"aws", "gcp", "azure"}:
         raise ValueError(f"Unknown cloud provider {cloud_provider}")
 
     client = Client()
@@ -2431,19 +2419,25 @@ def _get_stack_component_info(
 
         selected_storage = choices[selected_storage_idx]
 
+        flavor = selected_storage[0]
         config = {"path": selected_storage[1]}
         service_connector_resource_id = selected_storage[1]
     elif component_type == "orchestrator":
 
-        def query_gcp_region(compute_type: str) -> str:
+        def query_region(
+            provider: StackDeploymentProvider,
+            compute_type: str,
+            is_skypilot: bool = False,
+        ) -> str:
+            deployment_info = Client().zen_store.get_stack_deployment_info(
+                provider
+            )
             region = Prompt.ask(
                 f"Select the location for your {compute_type}:",
                 choices=sorted(
-                    Client()
-                    .zen_store.get_stack_deployment_info(
-                        StackDeploymentProvider.GCP
-                    )
-                    .locations.values()
+                    deployment_info.skypilot_default_regions.values()
+                    if is_skypilot
+                    else deployment_info.locations.values()
                 ),
                 show_choices=True,
             )
@@ -2467,10 +2461,22 @@ def _get_stack_component_info(
             config["execution_role"] = execution_role
         elif flavor == "vm_aws":
             config["region"] = selected_orchestrator[1]
+        elif flavor == "vm_gcp":
+            config["region"] = query_region(
+                StackDeploymentProvider.GCP,
+                "Skypilot cluster",
+                is_skypilot=True,
+            )
         elif flavor == "vm_azure":
-            config["region"] = query_gcp_region("Skypilot cluster")
+            config["region"] = query_region(
+                StackDeploymentProvider.AZURE,
+                "Skypilot cluster",
+                is_skypilot=True,
+            )
         elif flavor == "vertex":
-            config["location"] = query_gcp_region("Vertex AI job")
+            config["location"] = query_region(
+                StackDeploymentProvider.GCP, "Vertex AI job"
+            )
         service_connector_resource_id = selected_orchestrator[1]
     elif component_type == "container_registry":
         selected_registry_idx = cli_utils.multi_choice_prompt(
@@ -2482,6 +2488,7 @@ def _get_stack_component_info(
         if selected_registry_idx is None:
             cli_utils.error("No container registry selected.")
         selected_registry = choices[selected_registry_idx]
+        flavor = selected_registry[0]
         config = {"uri": selected_registry[1]}
         service_connector_resource_id = selected_registry[1]
     else:

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/enums.py

@@ -406,3 +406,4 @@ class StackDeploymentProvider(StrEnum):
 
     AWS = "aws"
     GCP = "gcp"
+    AZURE = "azure"

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/integrations/azure/__init__.py

@@ -42,7 +42,7 @@ class AzureIntegration(Integration):
         "adlfs>=2021.10.0",
         "azure-keyvault-keys",
         "azure-keyvault-secrets",
-        "azure-identity==1.10.0",
+        "azure-identity",
         "azureml-core==1.54.0.post1",
         "azure-mgmt-containerservice>=20.0.0",
         "azure-storage-blob==12.17.0",  # temporary fix for https://github.com/Azure/azure-sdk-for-python/issues/32056

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/integrations/skypilot_azure/__init__.py

@@ -19,13 +19,11 @@ orchestrator for a remote orchestration of ZenML pipelines on VMs.
 from typing import List, Type
 
 from zenml.integrations.constants import (
-
     SKYPILOT_AZURE,
 )
 from zenml.integrations.integration import Integration
 from zenml.stack import Flavor
 
-
 SKYPILOT_AZURE_ORCHESTRATOR_FLAVOR = "vm_azure"
 
 
@@ -33,7 +31,7 @@ class SkypilotAzureIntegration(Integration):
     """Definition of Skypilot (Azure) Integration for ZenML."""
 
     NAME = SKYPILOT_AZURE
-    REQUIREMENTS = ["skypilot[azure]~=0.6.0"]
+    REQUIREMENTS = ["skypilot-nightly[azure]==1.0.0.dev20240716"]
     APT_PACKAGES = ["openssh-client", "rsync"]
 
     @classmethod

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/models/v2/core/component.py

@@ -191,6 +191,17 @@ class ComponentResponseBody(WorkspaceScopedResponseBody):
         title="The flavor of the stack component.",
         max_length=STR_FIELD_MAX_LENGTH,
     )
+    integration: Optional[str] = Field(
+        default=None,
+        title="The name of the integration that the component's flavor "
+        "belongs to.",
+        max_length=STR_FIELD_MAX_LENGTH,
+    )
+    logo_url: Optional[str] = Field(
+        default=None,
+        title="Optionally, a url pointing to a png,"
+        "svg or jpg can be attached.",
+    )
 
 
 class ComponentResponseMetadata(WorkspaceScopedResponseMetadata):
@@ -285,6 +296,24 @@ class ComponentResponse(
         """
         return self.get_body().flavor
 
+    @property
+    def integration(self) -> Optional[str]:
+        """The `integration` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().integration
+
+    @property
+    def logo_url(self) -> Optional[str]:
+        """The `logo_url` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().logo_url
+
     @property
     def configuration(self) -> Dict[str, Any]:
         """The `configuration` property.

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/models/v2/misc/stack_deployment.py

@@ -55,6 +55,11 @@ class StackDeploymentInfo(BaseModel):
         description="The locations where the stack can be deployed, as a "
         "dictionary mapping location names to descriptions.",
     )
+    skypilot_default_regions: Dict[str, str] = Field(
+        title="The locations where the Skypilot clusters can be deployed by default.",
+        description="The locations where the Skypilot clusters can be deployed by default, as a "
+        "dictionary mapping location names to descriptions.",
+    )
 
 
 class StackDeploymentConfig(BaseModel):

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/service_connectors/service_connector_utils.py

@@ -66,6 +66,9 @@ def _raise_specific_cloud_exception_if_needed(
     GCP_DOCS = (
         "https://docs.zenml.io/how-to/auth-management/gcp-service-connector"
     )
+    AZURE_DOCS = (
+        "https://docs.zenml.io/how-to/auth-management/azure-service-connector"
+    )
 
     if not artifact_stores:
         error_msg = (
@@ -89,7 +92,12 @@ def _raise_specific_cloud_exception_if_needed(
                 )
             )
         elif cloud_provider == "azure":
-            pass
+            raise ValueError(
+                error_msg.format(
+                    obj_name="Blob Container",
+                    docs=f"{AZURE_DOCS}#azure-blob-storage-container",
+                )
+            )
     if not orchestrators:
         error_msg = (
             "We were unable to find any orchestrator engines "
@@ -105,7 +113,7 @@ def _raise_specific_cloud_exception_if_needed(
                 error_msg.format(
                     cloud_name="AWS",
                     gen_docs=f"{AWS_DOCS}#generic-aws-resource",
-                    k8s_name="Kubernetes",
+                    k8s_name="EKS",
                     k8s_docs=f"{AWS_DOCS}#eks-kubernetes-cluster",
                 )
             )
@@ -115,12 +123,19 @@ def _raise_specific_cloud_exception_if_needed(
                 error_msg.format(
                     cloud_name="GCP",
                     gen_docs=f"{GCP_DOCS}#generic-gcp-resource",
-                    k8s_name="GKE Kubernetes",
+                    k8s_name="GKE",
                     k8s_docs=f"{GCP_DOCS}#gke-kubernetes-cluster",
                 )
             )
         elif cloud_provider == "azure":
-            pass
+            raise ValueError(
+                error_msg.format(
+                    cloud_name="Azure",
+                    gen_docs=f"{AZURE_DOCS}#generic-azure-resource",
+                    k8s_name="AKS",
+                    k8s_docs=f"{AZURE_DOCS}#aks-kubernetes-cluster",
+                )
+            )
     if not container_registries:
         error_msg = (
             "We were unable to find any container registries "
@@ -145,7 +160,12 @@ def _raise_specific_cloud_exception_if_needed(
                 )
             )
         elif cloud_provider == "azure":
-            pass
+            raise ValueError(
+                error_msg.format(
+                    registry_name="ACR",
+                    docs_link=f"{AZURE_DOCS}#acr-container-registry",
+                )
+            )
 
 
 def get_resources_options_from_resource_model_for_full_stack(
@@ -162,15 +182,11 @@ def get_resources_options_from_resource_model_for_full_stack(
     client = Client()
     zen_store = client.zen_store
 
-    can_generate_long_tokens = False
     if isinstance(connector_details, UUID):
         resource_model = zen_store.verify_service_connector(
             connector_details,
             list_resources=True,
         )
-        can_generate_long_tokens = not zen_store.get_service_connector(
-            connector_details
-        ).configuration.get("generate_temporary_tokens", True)
     else:
         resource_model = zen_store.verify_service_connector_config(
             service_connector=ServiceConnectorRequest(
@@ -185,7 +201,6 @@ def get_resources_options_from_resource_model_for_full_stack(
             ),
             list_resources=True,
         )
-        can_generate_long_tokens = True
 
     resources = resource_model.resources
 
@@ -229,18 +244,17 @@ def get_resources_options_from_resource_model_for_full_stack(
                             flavor_display_name="AWS Sagemaker",
                         )
                     )
-                    if can_generate_long_tokens:
-                        orchestrators.append(
-                            _prepare_resource_info(
-                                connector_details=connector_details,
-                                resource_ids=each.resource_ids,
-                                stack_component_type=StackComponentType.ORCHESTRATOR,
-                                flavor="vm_aws",
-                                required_configuration={"region": "region"},
-                                use_resource_value_as_fixed_config=True,
-                                flavor_display_name="Skypilot (EC2)",
-                            )
+                    orchestrators.append(
+                        _prepare_resource_info(
+                            connector_details=connector_details,
+                            resource_ids=each.resource_ids,
+                            stack_component_type=StackComponentType.ORCHESTRATOR,
+                            flavor="vm_aws",
+                            required_configuration={"region": "region"},
+                            use_resource_value_as_fixed_config=True,
+                            flavor_display_name="Skypilot (EC2)",
                         )
+                    )
 
                 if each.resource_type == "kubernetes-cluster":
                     orchestrators.append(
@@ -291,19 +305,16 @@ def get_resources_options_from_resource_model_for_full_stack(
                             flavor_display_name="Vertex AI",
                         )
                     )
-                    if can_generate_long_tokens:
-                        orchestrators.append(
-                            _prepare_resource_info(
-                                connector_details=connector_details,
-                                resource_ids=each.resource_ids,
-                                stack_component_type=StackComponentType.ORCHESTRATOR,
-                                flavor="vm_gcp",
-                                required_configuration={
-                                    "region": "region name"
-                                },
-                                flavor_display_name="Skypilot (Compute)",
-                            )
+                    orchestrators.append(
+                        _prepare_resource_info(
+                            connector_details=connector_details,
+                            resource_ids=each.resource_ids,
+                            stack_component_type=StackComponentType.ORCHESTRATOR,
+                            flavor="vm_gcp",
+                            required_configuration={"region": "region name"},
+                            flavor_display_name="Skypilot (Compute)",
                         )
+                    )
 
                 if each.resource_type == "kubernetes-cluster":
                     orchestrators.append(
@@ -330,7 +341,55 @@ def get_resources_options_from_resource_model_for_full_stack(
                     )
 
     elif connector_type == "azure":
-        pass
+        for each in resources:
+            if each.resource_ids:
+                if each.resource_type == "blob-container":
+                    artifact_stores.append(
+                        _prepare_resource_info(
+                            connector_details=connector_details,
+                            resource_ids=each.resource_ids,
+                            stack_component_type=StackComponentType.ARTIFACT_STORE,
+                            flavor="azure",
+                            required_configuration={},
+                            flavor_display_name="Blob container",
+                        )
+                    )
+                if each.resource_type == "azure-generic":
+                    # No native orchestrator ATM
+                    orchestrators.append(
+                        _prepare_resource_info(
+                            connector_details=connector_details,
+                            resource_ids=each.resource_ids,
+                            stack_component_type=StackComponentType.ORCHESTRATOR,
+                            flavor="vm_azure",
+                            required_configuration={"region": "region name"},
+                            flavor_display_name="Skypilot (VM)",
+                        )
+                    )
+
+                if each.resource_type == "kubernetes-cluster":
+                    orchestrators.append(
+                        _prepare_resource_info(
+                            connector_details=connector_details,
+                            resource_ids=each.resource_ids,
+                            stack_component_type=StackComponentType.ORCHESTRATOR,
+                            flavor="kubernetes",
+                            required_configuration={},
+                            flavor_display_name="Kubernetes",
+                        )
+                    )
+                if each.resource_type == "docker-registry":
+                    container_registries.append(
+                        _prepare_resource_info(
+                            connector_details=connector_details,
+                            resource_ids=each.resource_ids,
+                            stack_component_type=StackComponentType.CONTAINER_REGISTRY,
+                            flavor="azure",
+                            required_configuration={"uri": "URI"},
+                            use_resource_value_as_fixed_config=True,
+                            flavor_display_name="ACR",
+                        )
+                    )
 
     _raise_specific_cloud_exception_if_needed(
         cloud_provider=connector_type,

zenml_nightly-0.62.0.dev20240720/src/zenml/stack_deployments/azure_stack_deployment.py

@@ -0,0 +1,179 @@
+#  Copyright (c) ZenML GmbH 2024. All Rights Reserved.
+
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+
+#       https://www.apache.org/licenses/LICENSE-2.0
+
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Functionality to deploy a ZenML stack to Azure."""
+
+import re
+from typing import ClassVar, Dict, List
+
+from zenml.enums import StackDeploymentProvider
+from zenml.stack_deployments.stack_deployment import ZenMLCloudStackDeployment
+
+
+# TODO: this class just implements the regions list, and is not suitable for other
+# deployment tasks.
+class AZUREZenMLCloudStackDeployment(ZenMLCloudStackDeployment):
+    """Azure ZenML Cloud Stack Deployment."""
+
+    provider: ClassVar[StackDeploymentProvider] = StackDeploymentProvider.AZURE
+
+    @classmethod
+    def description(cls) -> str:
+        """Return a description of the ZenML Cloud Stack Deployment.
+
+        This will be displayed when the user is prompted to deploy
+        the ZenML stack.
+
+        Returns:
+            A MarkDown description of the ZenML Cloud Stack Deployment.
+        """
+        # TODO: Implement this
+        return ""
+
+    @classmethod
+    def instructions(cls) -> str:
+        """Return instructions on how to deploy the ZenML stack to the specified cloud provider.
+
+        This will be displayed before the user is prompted to deploy the ZenML
+        stack.
+
+        Returns:
+            MarkDown instructions on how to deploy the ZenML stack to the
+            specified cloud provider.
+        """
+        # TODO: Implement this
+        return ""
+
+    @classmethod
+    def post_deploy_instructions(cls) -> str:
+        """Return instructions on what to do after the deployment is complete.
+
+        This will be displayed after the deployment is complete.
+
+        Returns:
+            MarkDown instructions on what to do after the deployment is
+            complete.
+        """
+        # TODO: Implement this
+        return ""
+
+    @classmethod
+    def integrations(cls) -> List[str]:
+        """Return the ZenML integrations required for the stack.
+
+        Returns:
+            The list of ZenML integrations that need to be installed for the
+            stack to be usable.
+        """
+        return ["azure"]
+
+    @classmethod
+    def permissions(cls) -> Dict[str, List[str]]:
+        """Return the permissions granted to ZenML to access the cloud resources.
+
+        Returns:
+            The permissions granted to ZenML to access the cloud resources, as
+            a dictionary grouping permissions by resource.
+        """
+        # TODO: Implement this
+        return {}
+
+    @classmethod
+    def locations(cls) -> Dict[str, str]:
+        """Return the locations where the ZenML stack can be deployed.
+
+        Returns:
+            The regions where the ZenML stack can be deployed as a map of region
+            names to region descriptions.
+        """
+        # Based on `az account list-locations -o table` on 16.07.2024
+        return {
+            "(US) East US": "eastus",
+            "(US) South Central US": "southcentralus",
+            "(US) West US 2": "westus2",
+            "(US) West US 3": "westus3",
+            "(Asia Pacific) Australia East": "australiaeast",
+            "(Asia Pacific) Southeast Asia": "southeastasia",
+            "(Europe) North Europe": "northeurope",
+            "(Europe) Sweden Central": "swedencentral",
+            "(Europe) UK South": "uksouth",
+            "(Europe) West Europe": "westeurope",
+            "(US) Central US": "centralus",
+            "(Africa) South Africa North": "southafricanorth",
+            "(Asia Pacific) Central India": "centralindia",
+            "(Asia Pacific) East Asia": "eastasia",
+            "(Asia Pacific) Japan East": "japaneast",
+            "(Asia Pacific) Korea Central": "koreacentral",
+            "(Canada) Canada Central": "canadacentral",
+            "(Europe) France Central": "francecentral",
+            "(Europe) Germany West Central": "germanywestcentral",
+            "(Europe) Italy North": "italynorth",
+            "(Europe) Norway East": "norwayeast",
+            "(Europe) Poland Central": "polandcentral",
+            "(Europe) Spain Central": "spaincentral",
+            "(Europe) Switzerland North": "switzerlandnorth",
+            "(Mexico) Mexico Central": "mexicocentral",
+            "(Middle East) UAE North": "uaenorth",
+            "(South America) Brazil South": "brazilsouth",
+            "(Middle East) Israel Central": "israelcentral",
+            "(Middle East) Qatar Central": "qatarcentral",
+            "(US) Central US (Stage)": "centralusstage",
+            "(US) East US (Stage)": "eastusstage",
+            "(US) East US 2 (Stage)": "eastus2stage",
+            "(US) North Central US (Stage)": "northcentralusstage",
+            "(US) South Central US (Stage)": "southcentralusstage",
+            "(US) West US (Stage)": "westusstage",
+            "(US) West US 2 (Stage)": "westus2stage",
+            "(Asia Pacific) East Asia (Stage)": "eastasiastage",
+            "(Asia Pacific) Southeast Asia (Stage)": "southeastasiastage",
+            "(South America) Brazil US": "brazilus",
+            "(US) East US 2": "eastus2",
+            "(US) East US STG": "eastusstg",
+            "(US) North Central US": "northcentralus",
+            "(US) West US": "westus",
+            "(Asia Pacific) Japan West": "japanwest",
+            "(Asia Pacific) Jio India West": "jioindiawest",
+            "(US) Central US EUAP": "centraluseuap",
+            "(US) East US 2 EUAP": "eastus2euap",
+            "(US) West Central US": "westcentralus",
+            "(Africa) South Africa West": "southafricawest",
+            "(Asia Pacific) Australia Central": "australiacentral",
+            "(Asia Pacific) Australia Central 2": "australiacentral2",
+            "(Asia Pacific) Australia Southeast": "australiasoutheast",
+            "(Asia Pacific) Jio India Central": "jioindiacentral",
+            "(Asia Pacific) Korea South": "koreasouth",
+            "(Asia Pacific) South India": "southindia",
+            "(Asia Pacific) West India": "westindia",
+            "(Canada) Canada East": "canadaeast",
+            "(Europe) France South": "francesouth",
+            "(Europe) Germany North": "germanynorth",
+            "(Europe) Norway West": "norwaywest",
+            "(Europe) Switzerland West": "switzerlandwest",
+            "(Europe) UK West": "ukwest",
+            "(Middle East) UAE Central": "uaecentral",
+            "(South America) Brazil Southeast": "brazilsoutheast",
+        }
+
+    @classmethod
+    def skypilot_default_regions(cls) -> Dict[str, str]:
+        """Returns the regions supported by default for the Skypilot.
+
+        Returns:
+            The regions supported by default for the Skypilot.
+        """
+        matcher = re.compile(r".*us\d*( |$)")
+        return {
+            k: v
+            for k, v in cls.locations().items()
+            if "(US)" in k and matcher.match(v)
+        }

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/stack_deployments/gcp_stack_deployment.py

@@ -13,6 +13,7 @@
 #  permissions and limitations under the License.
 """Functionality to deploy a ZenML stack to GCP."""
 
+import re
 from typing import ClassVar, Dict, List
 
 from zenml.enums import StackDeploymentProvider
@@ -208,6 +209,16 @@ GCP project and to clean up the resources created by the stack by using
             "US West (Las Vegas)": "us-west4",
         }
 
+    @classmethod
+    def skypilot_default_regions(cls) -> Dict[str, str]:
+        """Returns the regions supported by default for the Skypilot.
+
+        Returns:
+            The regions supported by default for the Skypilot.
+        """
+        matcher = re.compile(r"us-.*")
+        return {k: v for k, v in cls.locations().items() if matcher.match(v)}
+
     def get_deployment_config(
         self,
     ) -> StackDeploymentConfig:

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/stack_deployments/stack_deployment.py

@@ -105,6 +105,15 @@ class ZenMLCloudStackDeployment(BaseModel):
             names to region descriptions.
         """
 
+    @classmethod
+    def skypilot_default_regions(cls) -> Dict[str, str]:
+        """Returns the regions supported by default for the Skypilot.
+
+        Returns:
+            The regions supported by default for the Skypilot.
+        """
+        return cls.locations()
+
     @classmethod
     def get_deployment_info(cls) -> StackDeploymentInfo:
         """Return information about the ZenML Cloud Stack Deployment.
@@ -120,6 +129,7 @@ class ZenMLCloudStackDeployment(BaseModel):
             integrations=cls.integrations(),
             permissions=cls.permissions(),
             locations=cls.locations(),
+            skypilot_default_regions=cls.skypilot_default_regions(),
         )
 
     @abstractmethod

{zenml_nightly-0.62.0.dev20240717 → zenml_nightly-0.62.0.dev20240720}/src/zenml/stack_deployments/utils.py

@@ -19,6 +19,9 @@ from zenml.enums import StackDeploymentProvider
 from zenml.stack_deployments.aws_stack_deployment import (
     AWSZenMLCloudStackDeployment,
 )
+from zenml.stack_deployments.azure_stack_deployment import (
+    AZUREZenMLCloudStackDeployment,
+)
 from zenml.stack_deployments.gcp_stack_deployment import (
     GCPZenMLCloudStackDeployment,
 )
@@ -27,6 +30,7 @@ from zenml.stack_deployments.stack_deployment import ZenMLCloudStackDeployment
 STACK_DEPLOYMENT_PROVIDERS = {
     StackDeploymentProvider.AWS: AWSZenMLCloudStackDeployment,
     StackDeploymentProvider.GCP: GCPZenMLCloudStackDeployment,
+    StackDeploymentProvider.AZURE: AZUREZenMLCloudStackDeployment,
 }