zenml-nightly 0.55.0.dev20240124__py3-none-any.whl → 0.72.0.dev20250116__py3-none-any.whl

zenml/integrations/seldon/steps/seldon_deployer.py

@@ -73,13 +73,11 @@ def seldon_model_deployer_step(
     # get pipeline name, step name and run id
     context = get_step_context()
     pipeline_name = context.pipeline.name
-    run_name = context.pipeline_run.name
     step_name = context.step_run.name
 
     # update the step configuration with the real pipeline runtime information
-    service_config = service_config.copy()
+    service_config = service_config.model_copy()
     service_config.pipeline_name = pipeline_name
-    service_config.run_name = run_name
     service_config.pipeline_step_name = step_name
 
     def prepare_service_config(model_uri: str) -> SeldonDeploymentConfig:
@@ -143,9 +141,7 @@ def seldon_model_deployer_step(
     # fetch existing services with same pipeline name, step name and
     # model name
     existing_services = model_deployer.find_model_server(
-        pipeline_name=pipeline_name,
-        pipeline_step_name=step_name,
-        model_name=service_config.model_name,
+        config=service_config.model_dump()
     )
 
     # even when the deploy decision is negative, if an existing model server
@@ -173,7 +169,10 @@ def seldon_model_deployer_step(
     service = cast(
         SeldonDeploymentService,
         model_deployer.deploy_model(
-            service_config, replace=True, timeout=timeout
+            service_config,
+            replace=True,
+            timeout=timeout,
+            service_type=SeldonDeploymentService.SERVICE_TYPE,
         ),
     )
 
@@ -231,21 +230,17 @@ def seldon_custom_model_deployer_step(
     # get pipeline name, step name, run id
     context = get_step_context()
     pipeline_name = context.pipeline.name
-    run_name = context.pipeline_run.name
     step_name = context.step_run.name
 
     # update the step configuration with the real pipeline runtime information
     service_config.pipeline_name = pipeline_name
-    service_config.run_name = run_name
     service_config.pipeline_step_name = step_name
     service_config.is_custom_deployment = True
 
     # fetch existing services with the same pipeline name, step name and
     # model name
     existing_services = model_deployer.find_model_server(
-        pipeline_name=pipeline_name,
-        pipeline_step_name=step_name,
-        model_name=service_config.model_name,
+        config=service_config.model_dump()
     )
     # even when the deploy decision is negative if an existing model server
     # is not running for this pipeline/step, we still have to serve the
@@ -310,7 +305,7 @@ def seldon_custom_model_deployer_step(
     )
 
     # prepare the service configuration for the deployment
-    service_config = service_config.copy()
+    service_config = service_config.model_copy()
     service_config.model_uri = served_model_uri
 
     # create the specification for the custom deployment
@@ -325,7 +320,10 @@ def seldon_custom_model_deployer_step(
     service = cast(
         SeldonDeploymentService,
         model_deployer.deploy_model(
-            service_config, replace=True, timeout=timeout
+            service_config,
+            replace=True,
+            timeout=timeout,
+            service_type=SeldonDeploymentService.SERVICE_TYPE,
         ),
     )
 
@@ -378,15 +376,15 @@ def seldon_mlflow_registry_deployer_step(
     # Seldon Core model deployer are available
     if not registry_model_name:
         raise ValueError(
-            "registry_model_name must be provided to the MLflow"
+            "registry_model_name must be provided to the MLflow "
             "model registry deployer step."
         )
     elif not registry_model_version and not registry_model_stage:
         raise ValueError(
-            "Either registry_model_version or registry_model_stage must"
-            "be provided in addition to registry_model_name to the MLflow"
-            "model registry deployer step. Since the"
-            "mlflow_model_registry_deployer_step is used in conjunction with"
+            "Either registry_model_version or registry_model_stage must "
+            "be provided in addition to registry_model_name to the MLflow "
+            "model registry deployer step. Since the "
+            "mlflow_model_registry_deployer_step is used in conjunction with "
             "the mlflow_model_registry."
         )
     if service_config.implementation != "MLFLOW_SERVER":
@@ -476,7 +474,10 @@ def seldon_mlflow_registry_deployer_step(
     service = cast(
         SeldonDeploymentService,
         model_deployer.deploy_model(
-            service_config, replace=True, timeout=timeout
+            service_config,
+            replace=True,
+            timeout=timeout,
+            service_type=SeldonDeploymentService.SERVICE_TYPE,
         ),
     )
 

zenml/integrations/sklearn/__init__.py

@@ -21,7 +21,7 @@ class SklearnIntegration(Integration):
     """Definition of sklearn integration for ZenML."""
 
     NAME = SKLEARN
-    REQUIREMENTS = ["scikit-learn"]
+    REQUIREMENTS = ["scikit-learn", "scikit-image"]
 
     @classmethod
     def activate(cls) -> None:

zenml/integrations/skypilot/flavors/skypilot_orchestrator_base_vm_config.py

@@ -15,6 +15,8 @@
 
 from typing import Dict, List, Literal, Optional, Union
 
+from pydantic import Field
+
 from zenml.config.base_settings import BaseSettings
 from zenml.logger import get_logger
 from zenml.orchestrators import BaseOrchestratorConfig
@@ -41,7 +43,7 @@ class SkypilotBaseOrchestratorSettings(BaseSettings):
             `{'tpu_vm': True, 'runtime_version': 'tpu-vm-base'}` for TPUs.
         use_spot: whether to use spot instances. If None, defaults to
             False.
-        spot_recovery: the spot recovery strategy to use for the managed
+        job_recovery: the spot recovery strategy to use for the managed
             spot to recover the cluster from preemption. Refer to
             `recovery_strategy module <https://github.com/skypilot-org/skypilot/blob/master/sky/spot/recovery_strategy.py>`__ # pylint: disable=line-too-long
             for more details.
@@ -90,15 +92,23 @@ class SkypilotBaseOrchestratorSettings(BaseSettings):
 
     # Resources
     instance_type: Optional[str] = None
-    cpus: Union[None, int, float, str] = None
-    memory: Union[None, int, float, str] = None
-    accelerators: Union[None, str, Dict[str, int]] = None
+    cpus: Union[None, int, float, str] = Field(
+        default=None, union_mode="left_to_right"
+    )
+    memory: Union[None, int, float, str] = Field(
+        default=None, union_mode="left_to_right"
+    )
+    accelerators: Union[None, str, Dict[str, int]] = Field(
+        default=None, union_mode="left_to_right"
+    )
     accelerator_args: Optional[Dict[str, str]] = None
     use_spot: Optional[bool] = None
-    spot_recovery: Optional[str] = None
+    job_recovery: Optional[str] = None
     region: Optional[str] = None
     zone: Optional[str] = None
-    image_id: Union[Dict[str, str], str, None] = None
+    image_id: Union[Dict[str, str], str, None] = Field(
+        default=None, union_mode="left_to_right"
+    )
     disk_size: Optional[int] = None
     disk_tier: Optional[Literal["high", "medium", "low"]] = None
 
@@ -112,7 +122,7 @@ class SkypilotBaseOrchestratorSettings(BaseSettings):
     docker_run_args: List[str] = []
 
 
-class SkypilotBaseOrchestratorConfig(  # type: ignore[misc] # https://github.com/pydantic/pydantic/issues/4173
+class SkypilotBaseOrchestratorConfig(
     BaseOrchestratorConfig, SkypilotBaseOrchestratorSettings
 ):
     """Skypilot orchestrator base config.
@@ -134,3 +144,15 @@ class SkypilotBaseOrchestratorConfig(  # type: ignore[misc] # https://github.com
             True if this config is for a local component, False otherwise.
         """
         return False
+
+    @property
+    def supports_client_side_caching(self) -> bool:
+        """Whether the orchestrator supports client side caching.
+
+        Returns:
+            Whether the orchestrator supports client side caching.
+        """
+        # The Skypilot orchestrator runs the entire pipeline in a single VM, or
+        # starts additional VMs from the root VM. Both of those cases are
+        # currently not supported when using client-side caching.
+        return False

zenml/integrations/skypilot/orchestrators/skypilot_base_vm_orchestrator.py

@@ -174,16 +174,16 @@ class SkypilotBaseOrchestrator(ContainerizedOrchestrator):
             )
         if deployment.schedule:
             logger.warning(
-                "Skypilot Orchestrator currently does not support the"
+                "Skypilot Orchestrator currently does not support the "
                 "use of schedules. The `schedule` will be ignored "
                 "and the pipeline will be run immediately."
             )
 
         # Set up some variables for configuration
         orchestrator_run_id = str(uuid4())
-        environment[
-            ENV_ZENML_SKYPILOT_ORCHESTRATOR_RUN_ID
-        ] = orchestrator_run_id
+        environment[ENV_ZENML_SKYPILOT_ORCHESTRATOR_RUN_ID] = (
+            orchestrator_run_id
+        )
 
         settings = cast(
             SkypilotBaseOrchestratorSettings,
@@ -250,9 +250,13 @@ class SkypilotBaseOrchestrator(ContainerizedOrchestrator):
         entrypoint_str = " ".join(command)
         arguments_str = " ".join(args)
 
+        task_envs = environment
         docker_environment_str = " ".join(
             f"-e {k}={v}" for k, v in environment.items()
         )
+        custom_run_args = " ".join(settings.docker_run_args)
+        if custom_run_args:
+            custom_run_args += " "
 
         instance_type = settings.instance_type or self.DEFAULT_INSTANCE_TYPE
 
@@ -265,16 +269,13 @@ class SkypilotBaseOrchestrator(ContainerizedOrchestrator):
         if docker_creds := stack.container_registry.credentials:
             docker_username, docker_password = docker_creds
             setup = (
-                f"docker login --username $DOCKER_USERNAME --password "
+                f"sudo docker login --username $DOCKER_USERNAME --password "
                 f"$DOCKER_PASSWORD {stack.container_registry.config.uri}"
             )
-            task_envs = {
-                "DOCKER_USERNAME": docker_username,
-                "DOCKER_PASSWORD": docker_password,
-            }
+            task_envs["DOCKER_USERNAME"] = docker_username
+            task_envs["DOCKER_PASSWORD"] = docker_password
         else:
             setup = None
-            task_envs = None
 
         # Run the entire pipeline
 
@@ -282,11 +283,22 @@ class SkypilotBaseOrchestrator(ContainerizedOrchestrator):
         self.prepare_environment_variable(set=True)
 
         try:
+            if isinstance(self.cloud, sky.clouds.Kubernetes):
+                run_command = f"${{VIRTUAL_ENV:+$VIRTUAL_ENV/bin/}}{entrypoint_str} {arguments_str}"
+                setup = None
+                down = False
+                idle_minutes_to_autostop = None
+            else:
+                run_command = f"sudo docker run --rm {custom_run_args}{docker_environment_str} {image} {entrypoint_str} {arguments_str}"
+                down = settings.down
+                idle_minutes_to_autostop = settings.idle_minutes_to_autostop
             task = sky.Task(
-                run=f"docker run --rm {docker_environment_str} {image} {entrypoint_str} {arguments_str}",
+                run=run_command,
                 setup=setup,
                 envs=task_envs,
             )
+            logger.debug(f"Running run: {run_command}")
+
             task = task.set_resources(
                 sky.Resources(
                     cloud=self.cloud,
@@ -296,18 +308,27 @@ class SkypilotBaseOrchestrator(ContainerizedOrchestrator):
                     accelerators=settings.accelerators,
                     accelerator_args=settings.accelerator_args,
                     use_spot=settings.use_spot,
-                    spot_recovery=settings.spot_recovery,
+                    job_recovery=settings.job_recovery,
                     region=settings.region,
                     zone=settings.zone,
-                    image_id=settings.image_id,
+                    image_id=image
+                    if isinstance(self.cloud, sky.clouds.Kubernetes)
+                    else settings.image_id,
                     disk_size=settings.disk_size,
                     disk_tier=settings.disk_tier,
                 )
             )
-
             # Set the cluster name
-            cluster_name = settings.cluster_name
-            if cluster_name is None:
+            if settings.cluster_name:
+                sky.exec(
+                    task,
+                    settings.cluster_name,
+                    down=down,
+                    stream_logs=settings.stream_logs,
+                    backend=None,
+                    detach_run=True,
+                )
+            else:
                 # Find existing cluster
                 for i in sky.status(refresh=True):
                     if isinstance(
@@ -317,21 +338,19 @@ class SkypilotBaseOrchestrator(ContainerizedOrchestrator):
                         logger.info(
                             f"Found existing cluster {cluster_name}. Reusing..."
                         )
-            if cluster_name is None:
                 cluster_name = self.sanitize_cluster_name(
                     f"{orchestrator_run_name}"
                 )
-
-            # Launch the cluster
-            sky.launch(
-                task,
-                cluster_name,
-                retry_until_up=settings.retry_until_up,
-                idle_minutes_to_autostop=settings.idle_minutes_to_autostop,
-                down=settings.down,
-                stream_logs=settings.stream_logs,
-                detach_setup=True,
-            )
+                # Launch the cluster
+                sky.launch(
+                    task,
+                    cluster_name,
+                    retry_until_up=settings.retry_until_up,
+                    idle_minutes_to_autostop=idle_minutes_to_autostop,
+                    down=down,
+                    stream_logs=settings.stream_logs,
+                    detach_setup=True,
+                )
 
         except Exception as e:
             logger.error(f"Pipeline run failed: {e}")

zenml/integrations/skypilot/orchestrators/skypilot_orchestrator_entrypoint.py

@@ -136,7 +136,7 @@ def main() -> None:
             settings.disk_size,  # Assuming disk_size is part of the settings
             settings.disk_tier,  # Assuming disk_tier is part of the settings
             settings.use_spot,
-            settings.spot_recovery,
+            settings.job_recovery,
             settings.region,
             settings.zone,
             accelerators_hashable,
@@ -213,7 +213,7 @@ def main() -> None:
                 accelerators=settings.accelerators,
                 accelerator_args=settings.accelerator_args,
                 use_spot=settings.use_spot,
-                spot_recovery=settings.spot_recovery,
+                job_recovery=settings.job_recovery,
                 region=settings.region,
                 zone=settings.zone,
                 image_id=settings.image_id,

zenml/integrations/skypilot_aws/__init__.py

@@ -31,8 +31,9 @@ class SkypilotAWSIntegration(Integration):
     """Definition of Skypilot AWS Integration for ZenML."""
 
     NAME = SKYPILOT_AWS
-    REQUIREMENTS = ["skypilot[aws]<=0.4.1"]
-    APT_PACKAGES = ["openssh-client","rsync"]
+    # all 0.6.x versions of skypilot[aws] are compatible
+    REQUIREMENTS = ["skypilot[aws]~=0.6.0"]
+    APT_PACKAGES = ["openssh-client", "rsync"]
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/skypilot_aws/flavors/skypilot_orchestrator_aws_vm_flavor.py

@@ -37,7 +37,7 @@ class SkypilotAWSOrchestratorSettings(SkypilotBaseOrchestratorSettings):
     """Skypilot orchestrator settings."""
 
 
-class SkypilotAWSOrchestratorConfig(  # type: ignore[misc] # https://github.com/pydantic/pydantic/issues/4173
+class SkypilotAWSOrchestratorConfig(
     SkypilotBaseOrchestratorConfig, SkypilotAWSOrchestratorSettings
 ):
     """Skypilot orchestrator config."""

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,8 +31,8 @@ class SkypilotAzureIntegration(Integration):
     """Definition of Skypilot (Azure) Integration for ZenML."""
 
     NAME = SKYPILOT_AZURE
-    REQUIREMENTS = ["skypilot[azure]<=0.4.1"]
-    APT_PACKAGES = ["openssh-client","rsync"]
+    REQUIREMENTS = ["skypilot[azure]>=0.6.1"]
+    APT_PACKAGES = ["openssh-client", "rsync"]
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/skypilot_azure/flavors/skypilot_orchestrator_azure_vm_flavor.py

@@ -39,7 +39,7 @@ class SkypilotAzureOrchestratorSettings(SkypilotBaseOrchestratorSettings):
     """Skypilot orchestrator settings for Azure."""
 
 
-class SkypilotAzureOrchestratorConfig(  # type: ignore[misc] # https://github.com/pydantic/pydantic/issues/4173
+class SkypilotAzureOrchestratorConfig(
     SkypilotBaseOrchestratorConfig, SkypilotAzureOrchestratorSettings
 ):
     """Skypilot orchestrator config for Azure."""

zenml/integrations/skypilot_gcp/__init__.py

@@ -26,12 +26,13 @@ from zenml.stack import Flavor
 
 SKYPILOT_GCP_ORCHESTRATOR_FLAVOR = "vm_gcp"
 
+
 class SkypilotGCPIntegration(Integration):
     """Definition of Skypilot (GCP) Integration for ZenML."""
 
     NAME = SKYPILOT_GCP
-    REQUIREMENTS = ["skypilot[gcp]<=0.4.1"]
-    APT_PACKAGES = ["openssh-client","rsync"]
+    REQUIREMENTS = ["skypilot[gcp]~=0.6.0"]
+    APT_PACKAGES = ["openssh-client", "rsync"]
 
     @classmethod
     def flavors(cls) -> List[Type[Flavor]]:

zenml/integrations/skypilot_gcp/flavors/skypilot_orchestrator_gcp_vm_flavor.py

@@ -40,7 +40,7 @@ class SkypilotGCPOrchestratorSettings(SkypilotBaseOrchestratorSettings):
     """Skypilot orchestrator settings for GCP."""
 
 
-class SkypilotGCPOrchestratorConfig(  # type: ignore[misc] # https://github.com/pydantic/pydantic/issues/4173
+class SkypilotGCPOrchestratorConfig(
     SkypilotBaseOrchestratorConfig,
     GoogleCredentialsConfigMixin,
     SkypilotGCPOrchestratorSettings,

zenml/integrations/skypilot_kubernetes/__init__.py

@@ -0,0 +1,52 @@
+#  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.
+"""Initialization of the Skypilot Kubernetes integration for ZenML.
+
+The Skypilot integration sub-module powers an alternative to the local
+orchestrator for a remote orchestration of ZenML pipelines on VMs.
+"""
+from typing import List, Type
+
+from zenml.integrations.constants import (
+    SKYPILOT_KUBERNETES,
+)
+from zenml.integrations.integration import Integration
+from zenml.stack import Flavor
+
+SKYPILOT_KUBERNETES_ORCHESTRATOR_FLAVOR = "vm_kubernetes"
+
+
+class SkypilotKubernetesIntegration(Integration):
+    """Definition of Skypilot Kubernetes Integration for ZenML."""
+
+    NAME = SKYPILOT_KUBERNETES
+    # all 0.6.x versions of skypilot[kubernetes] are compatible
+    REQUIREMENTS = ["skypilot[kubernetes]~=0.6.1"]
+    APT_PACKAGES = ["openssh-client", "rsync"]
+
+    @classmethod
+    def flavors(cls) -> List[Type[Flavor]]:
+        """Declare the stack component flavors for the Skypilot Kubernetes integration.
+
+        Returns:
+            List of stack component flavors for this integration.
+        """
+        from zenml.integrations.skypilot_kubernetes.flavors import (
+            SkypilotKubernetesOrchestratorFlavor,
+        )
+
+        return [SkypilotKubernetesOrchestratorFlavor]
+
+
+SkypilotKubernetesIntegration.check_installation()

zenml/integrations/skypilot_kubernetes/flavors/__init__.py

@@ -0,0 +1,26 @@
+#  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.
+"""Skypilot integration flavor for Skypilot Kubernetes orchestrator."""
+
+from zenml.integrations.skypilot_kubernetes.flavors.skypilot_orchestrator_kubernetes_vm_flavor import (
+    SkypilotKubernetesOrchestratorConfig,
+    SkypilotKubernetesOrchestratorFlavor,
+    SkypilotKubernetesOrchestratorSettings,
+)
+
+__all__ = [
+    "SkypilotKubernetesOrchestratorConfig",
+    "SkypilotKubernetesOrchestratorFlavor",
+    "SkypilotKubernetesOrchestratorSettings",
+]

zenml/integrations/skypilot_kubernetes/flavors/skypilot_orchestrator_kubernetes_vm_flavor.py

@@ -0,0 +1,125 @@
+#  Copyright (c) ZenML GmbH 2023. 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.
+"""Skypilot orchestrator Kubernetes flavor."""
+
+from typing import TYPE_CHECKING, Optional, Type
+
+from zenml.constants import KUBERNETES_CLUSTER_RESOURCE_TYPE
+from zenml.integrations.skypilot.flavors.skypilot_orchestrator_base_vm_config import (
+    SkypilotBaseOrchestratorConfig,
+    SkypilotBaseOrchestratorSettings,
+)
+from zenml.integrations.skypilot_kubernetes import (
+    SKYPILOT_KUBERNETES_ORCHESTRATOR_FLAVOR,
+)
+from zenml.logger import get_logger
+from zenml.models import ServiceConnectorRequirements
+from zenml.orchestrators import BaseOrchestratorConfig, BaseOrchestratorFlavor
+
+if TYPE_CHECKING:
+    from zenml.integrations.skypilot_kubernetes.orchestrators import (
+        SkypilotKubernetesOrchestrator,
+    )
+
+
+logger = get_logger(__name__)
+
+
+class SkypilotKubernetesOrchestratorSettings(SkypilotBaseOrchestratorSettings):
+    """Skypilot orchestrator settings."""
+
+
+class SkypilotKubernetesOrchestratorConfig(
+    SkypilotBaseOrchestratorConfig, SkypilotKubernetesOrchestratorSettings
+):
+    """Skypilot orchestrator config."""
+
+
+class SkypilotKubernetesOrchestratorFlavor(BaseOrchestratorFlavor):
+    """Flavor for the Skypilot Kubernetes orchestrator."""
+
+    @property
+    def name(self) -> str:
+        """Name of the orchestrator flavor.
+
+        Returns:
+            Name of the orchestrator flavor.
+        """
+        return SKYPILOT_KUBERNETES_ORCHESTRATOR_FLAVOR
+
+    @property
+    def service_connector_requirements(
+        self,
+    ) -> Optional[ServiceConnectorRequirements]:
+        """Service connector resource requirements for service connectors.
+
+        Specifies resource requirements that are used to filter the available
+        service connector types that are compatible with this flavor.
+
+        Returns:
+            Requirements for compatible service connectors, if a service
+            connector is required for this flavor.
+        """
+        return ServiceConnectorRequirements(
+            resource_type=KUBERNETES_CLUSTER_RESOURCE_TYPE,
+        )
+
+    @property
+    def docs_url(self) -> Optional[str]:
+        """A url to point at docs explaining this flavor.
+
+        Returns:
+            A flavor docs url.
+        """
+        return self.generate_default_docs_url()
+
+    @property
+    def sdk_docs_url(self) -> Optional[str]:
+        """A url to point at SDK docs explaining this flavor.
+
+        Returns:
+            A flavor SDK docs url.
+        """
+        return self.generate_default_sdk_docs_url()
+
+    @property
+    def logo_url(self) -> str:
+        """A url to represent the flavor in the dashboard.
+
+        Returns:
+            The flavor logo.
+        """
+        return "https://public-flavor-logos.s3.eu-central-1.amazonaws.com/orchestrator/kubernetes-skypilot.png"
+
+    @property
+    def config_class(self) -> Type[BaseOrchestratorConfig]:
+        """Config class for the base orchestrator flavor.
+
+        Returns:
+            The config class.
+        """
+        return SkypilotKubernetesOrchestratorConfig
+
+    @property
+    def implementation_class(self) -> Type["SkypilotKubernetesOrchestrator"]:
+        """Implementation class for this flavor.
+
+        Returns:
+            Implementation class for this flavor.
+        """
+        from zenml.integrations.skypilot_kubernetes.orchestrators import (
+            SkypilotKubernetesOrchestrator,
+        )
+
+        return SkypilotKubernetesOrchestrator

zenml/integrations/skypilot_kubernetes/orchestrators/__init__.py

@@ -0,0 +1,25 @@
+#  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.
+"""Initialization of the Skypilot Kubernetes ZenML orchestrator."""
+
+from zenml.integrations.skypilot.orchestrators.skypilot_base_vm_orchestrator import (  # noqa
+    SkypilotBaseOrchestrator,
+)
+from zenml.integrations.skypilot_kubernetes.orchestrators.skypilot_kubernetes_vm_orchestrator import (  # noqa
+    SkypilotKubernetesOrchestrator,
+)
+__all__ = [
+    "SkypilotBaseOrchestrator",
+    "SkypilotKubernetesOrchestrator",
+]