zenml-nightly 0.70.0.dev20241127__py3-none-any.whl → 0.70.0.dev20241128__py3-none-any.whl

zenml/VERSION

@@ -1 +1 @@
-0.70.0.dev20241127
+0.70.0.dev20241128

zenml/integrations/__init__.py

@@ -48,6 +48,7 @@ from zenml.integrations.lightgbm import LightGBMIntegration  # noqa
 
 # from zenml.integrations.llama_index import LlamaIndexIntegration  # noqa
 from zenml.integrations.mlflow import MlflowIntegration  # noqa
+from zenml.integrations.modal import ModalIntegration  # noqa
 from zenml.integrations.neptune import NeptuneIntegration  # noqa
 from zenml.integrations.neural_prophet import NeuralProphetIntegration  # noqa
 from zenml.integrations.numpy import NumpyIntegration  # noqa

zenml/integrations/constants.py

@@ -42,6 +42,7 @@ LANGCHAIN = "langchain"
 LIGHTGBM = "lightgbm"
 # LLAMA_INDEX = "llama_index"
 MLFLOW = "mlflow"
+MODAL = "modal"
 NEPTUNE = "neptune"
 NEURAL_PROPHET = "neural_prophet"
 NUMPY = "numpy"

zenml/integrations/kubernetes/orchestrators/kube_utils.py

@@ -94,18 +94,62 @@ def load_kube_config(
         k8s_config.load_kube_config(context=context)
 
 
-def sanitize_pod_name(pod_name: str) -> str:
+def calculate_max_pod_name_length_for_namespace(namespace: str) -> int:
+    """Calculate the max pod length for a certain namespace.
+
+    Args:
+        namespace: The namespace in which the pod will be created.
+
+    Returns:
+        The maximum pod name length.
+    """
+    # Kubernetes allows Pod names to have 253 characters. However, when
+    # creating a pod they try to create a log file which is called
+    # <NAMESPACE>_<POD_NAME>_<UUID>, which adds additional characters and
+    # runs into filesystem limitations for filename lengths (255). We therefore
+    # subtract the length of a UUID (36), the two underscores and the
+    # namespace length from the max filename length.
+    return 255 - 38 - len(namespace)
+
+
+def sanitize_pod_name(pod_name: str, namespace: str) -> str:
     """Sanitize pod names so they conform to Kubernetes pod naming convention.
 
     Args:
         pod_name: Arbitrary input pod name.
+        namespace: Namespace in which the Pod will be created.
 
     Returns:
         Sanitized pod name.
     """
+    # https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#dns-subdomain-names
     pod_name = re.sub(r"[^a-z0-9-]", "-", pod_name.lower())
     pod_name = re.sub(r"^[-]+", "", pod_name)
-    return re.sub(r"[-]+", "-", pod_name)
+    pod_name = re.sub(r"[-]+$", "", pod_name)
+    pod_name = re.sub(r"[-]+", "-", pod_name)
+
+    allowed_length = calculate_max_pod_name_length_for_namespace(
+        namespace=namespace
+    )
+    return pod_name[:allowed_length]
+
+
+def sanitize_label(label: str) -> str:
+    """Sanitize a label for a Kubernetes resource.
+
+    Args:
+        label: The label to sanitize.
+
+    Returns:
+        The sanitized label.
+    """
+    # https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#rfc-1035-label-names
+    label = re.sub(r"[^a-z0-9-]", "-", label.lower())
+    label = re.sub(r"^[-]+", "", label)
+    label = re.sub(r"[-]+$", "", label)
+    label = re.sub(r"[-]+", "-", label)
+
+    return label[:63]
 
 
 def pod_is_not_pending(pod: k8s_client.V1Pod) -> bool:

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator.py

@@ -395,8 +395,19 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 )
 
         pipeline_name = deployment.pipeline_configuration.name
-        orchestrator_run_name = get_orchestrator_run_name(pipeline_name)
-        pod_name = kube_utils.sanitize_pod_name(orchestrator_run_name)
+
+        # We already make sure the orchestrator run name has the correct length
+        # to make sure we don't cut off the randomized suffix later when
+        # sanitizing the pod name. This avoids any pod naming collisions.
+        max_length = kube_utils.calculate_max_pod_name_length_for_namespace(
+            namespace=self.config.kubernetes_namespace
+        )
+        orchestrator_run_name = get_orchestrator_run_name(
+            pipeline_name, max_length=max_length
+        )
+        pod_name = kube_utils.sanitize_pod_name(
+            orchestrator_run_name, namespace=self.config.kubernetes_namespace
+        )
 
         assert stack.container_registry
 

zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py

@@ -90,7 +90,9 @@ def main() -> None:
         """
         # Define Kubernetes pod name.
         pod_name = f"{orchestrator_run_id}-{step_name}"
-        pod_name = kube_utils.sanitize_pod_name(pod_name)
+        pod_name = kube_utils.sanitize_pod_name(
+            pod_name, namespace=args.kubernetes_namespace
+        )
 
         image = KubernetesOrchestrator.get_image(
             deployment=deployment_config, step_name=step_name

zenml/integrations/kubernetes/orchestrators/manifest_utils.py

@@ -25,6 +25,7 @@ from zenml.constants import ENV_ZENML_ENABLE_REPO_INIT_WARNINGS
 from zenml.integrations.airflow.orchestrators.dag_generator import (
     ENV_ZENML_LOCAL_STORES_PATH,
 )
+from zenml.integrations.kubernetes.orchestrators import kube_utils
 from zenml.integrations.kubernetes.pod_settings import KubernetesPodSettings
 
 
@@ -167,8 +168,8 @@ def build_pod_manifest(
     # Add run_name and pipeline_name to the labels
     labels.update(
         {
-            "run": run_name,
-            "pipeline": pipeline_name,
+            "run": kube_utils.sanitize_label(run_name),
+            "pipeline": kube_utils.sanitize_label(pipeline_name),
         }
     )
 

zenml/integrations/kubernetes/step_operators/kubernetes_step_operator.py

@@ -197,7 +197,9 @@ class KubernetesStepOperator(BaseStepOperator):
         )
 
         pod_name = f"{info.run_name}_{info.pipeline_step_name}"
-        pod_name = kube_utils.sanitize_pod_name(pod_name)
+        pod_name = kube_utils.sanitize_pod_name(
+            pod_name, namespace=self.config.kubernetes_namespace
+        )
 
         command = entrypoint_command[:3]
         args = entrypoint_command[3:]

zenml/integrations/modal/__init__.py

@@ -0,0 +1,46 @@
+#  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.
+"""Modal integration for cloud-native step execution.
+
+The Modal integration sub-module provides a step operator flavor that allows
+executing steps on Modal's cloud infrastructure.
+"""
+from typing import List, Type
+
+from zenml.integrations.constants import MODAL
+from zenml.integrations.integration import Integration
+from zenml.stack import Flavor
+
+MODAL_STEP_OPERATOR_FLAVOR = "modal"
+
+
+class ModalIntegration(Integration):
+    """Definition of Modal integration for ZenML."""
+
+    NAME = MODAL
+    REQUIREMENTS = ["modal>=0.64.49,<1"]
+
+    @classmethod
+    def flavors(cls) -> List[Type[Flavor]]:
+        """Declare the stack component flavors for the Modal integration.
+
+        Returns:
+            List of new stack component flavors.
+        """
+        from zenml.integrations.modal.flavors import ModalStepOperatorFlavor
+
+        return [ModalStepOperatorFlavor]
+
+
+ModalIntegration.check_installation()

zenml/integrations/modal/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.
+"""Modal integration flavors."""
+
+from zenml.integrations.modal.flavors.modal_step_operator_flavor import (
+    ModalStepOperatorConfig,
+    ModalStepOperatorFlavor,
+    ModalStepOperatorSettings,
+)
+
+__all__ = [
+    "ModalStepOperatorConfig",
+    "ModalStepOperatorFlavor",
+    "ModalStepOperatorSettings",
+]

zenml/integrations/modal/flavors/modal_step_operator_flavor.py

@@ -0,0 +1,125 @@
+#  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.
+"""Modal step operator flavor."""
+
+from typing import TYPE_CHECKING, Optional, Type
+
+from zenml.config.base_settings import BaseSettings
+from zenml.integrations.modal import MODAL_STEP_OPERATOR_FLAVOR
+from zenml.step_operators import BaseStepOperatorConfig, BaseStepOperatorFlavor
+
+if TYPE_CHECKING:
+    from zenml.integrations.modal.step_operators import ModalStepOperator
+
+
+class ModalStepOperatorSettings(BaseSettings):
+    """Settings for the Modal step operator.
+
+    Specifying the region and cloud provider is only available for Enterprise
+    and Team plan customers.
+
+    Certain combinations of settings are not available. It is suggested to err
+    on the side of looser settings rather than more restrictive ones to avoid
+    pipeline execution failures. In the case of failures, however, Modal
+    provides detailed error messages that can help identify what is
+    incompatible. See more in the Modal docs at https://modal.com/docs/guide/region-selection.
+
+    Attributes:
+        gpu: The type of GPU to use for the step execution.
+        region: The region to use for the step execution.
+        cloud: The cloud provider to use for the step execution.
+    """
+
+    gpu: Optional[str] = None
+    region: Optional[str] = None
+    cloud: Optional[str] = None
+
+
+class ModalStepOperatorConfig(
+    BaseStepOperatorConfig, ModalStepOperatorSettings
+):
+    """Configuration for the Modal step operator."""
+
+    @property
+    def is_remote(self) -> bool:
+        """Checks if this stack component is running remotely.
+
+        This designation is used to determine if the stack component can be
+        used with a local ZenML database or if it requires a remote ZenML
+        server.
+
+        Returns:
+            True if this config is for a remote component, False otherwise.
+        """
+        return True
+
+
+class ModalStepOperatorFlavor(BaseStepOperatorFlavor):
+    """Modal step operator flavor."""
+
+    @property
+    def name(self) -> str:
+        """Name of the flavor.
+
+        Returns:
+            The name of the flavor.
+        """
+        return MODAL_STEP_OPERATOR_FLAVOR
+
+    @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/step_operator/modal.png"
+
+    @property
+    def config_class(self) -> Type[ModalStepOperatorConfig]:
+        """Returns `ModalStepOperatorConfig` config class.
+
+        Returns:
+            The config class.
+        """
+        return ModalStepOperatorConfig
+
+    @property
+    def implementation_class(self) -> Type["ModalStepOperator"]:
+        """Implementation class for this flavor.
+
+        Returns:
+            The implementation class.
+        """
+        from zenml.integrations.modal.step_operators import ModalStepOperator
+
+        return ModalStepOperator

zenml/integrations/modal/step_operators/__init__.py

@@ -0,0 +1,22 @@
+#  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.
+"""Modal step operator."""
+
+from zenml.integrations.modal.step_operators.modal_step_operator import (
+    ModalStepOperator,
+)
+
+__all__ = [
+    "ModalStepOperator",
+]

zenml/integrations/modal/step_operators/modal_step_operator.py

@@ -0,0 +1,242 @@
+#  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.
+"""Modal step operator implementation."""
+
+import asyncio
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Type, cast
+
+import modal
+from modal_proto import api_pb2
+
+from zenml.client import Client
+from zenml.config.build_configuration import BuildConfiguration
+from zenml.config.resource_settings import ByteUnit, ResourceSettings
+from zenml.enums import StackComponentType
+from zenml.integrations.modal.flavors import (
+    ModalStepOperatorConfig,
+    ModalStepOperatorSettings,
+)
+from zenml.logger import get_logger
+from zenml.stack import Stack, StackValidator
+from zenml.step_operators import BaseStepOperator
+
+if TYPE_CHECKING:
+    from zenml.config.base_settings import BaseSettings
+    from zenml.config.step_run_info import StepRunInfo
+    from zenml.models import PipelineDeploymentBase
+
+logger = get_logger(__name__)
+
+MODAL_STEP_OPERATOR_DOCKER_IMAGE_KEY = "modal_step_operator"
+
+
+def get_gpu_values(
+    settings: ModalStepOperatorSettings, resource_settings: ResourceSettings
+) -> Optional[str]:
+    """Get the GPU values for the Modal step operator.
+
+    Args:
+        settings: The Modal step operator settings.
+        resource_settings: The resource settings.
+
+    Returns:
+        The GPU string if a count is specified, otherwise the GPU type.
+    """
+    if not settings.gpu:
+        return None
+    gpu_count = resource_settings.gpu_count
+    return f"{settings.gpu}:{gpu_count}" if gpu_count else settings.gpu
+
+
+class ModalStepOperator(BaseStepOperator):
+    """Step operator to run a step on Modal.
+
+    This class defines code that can set up a Modal environment and run
+    functions in it.
+    """
+
+    @property
+    def config(self) -> ModalStepOperatorConfig:
+        """Get the Modal step operator configuration.
+
+        Returns:
+            The Modal step operator configuration.
+        """
+        return cast(ModalStepOperatorConfig, self._config)
+
+    @property
+    def settings_class(self) -> Optional[Type["BaseSettings"]]:
+        """Get the settings class for the Modal step operator.
+
+        Returns:
+            The Modal step operator settings class.
+        """
+        return ModalStepOperatorSettings
+
+    @property
+    def validator(self) -> Optional[StackValidator]:
+        """Get the stack validator for the Modal step operator.
+
+        Returns:
+            The stack validator.
+        """
+
+        def _validate_remote_components(stack: "Stack") -> Tuple[bool, str]:
+            if stack.artifact_store.config.is_local:
+                return False, (
+                    "The Modal step operator runs code remotely and "
+                    "needs to write files into the artifact store, but the "
+                    f"artifact store `{stack.artifact_store.name}` of the "
+                    "active stack is local. Please ensure that your stack "
+                    "contains a remote artifact store when using the Modal "
+                    "step operator."
+                )
+
+            container_registry = stack.container_registry
+            assert container_registry is not None
+
+            if container_registry.config.is_local:
+                return False, (
+                    "The Modal step operator runs code remotely and "
+                    "needs to push/pull Docker images, but the "
+                    f"container registry `{container_registry.name}` of the "
+                    "active stack is local. Please ensure that your stack "
+                    "contains a remote container registry when using the "
+                    "Modal step operator."
+                )
+
+            return True, ""
+
+        return StackValidator(
+            required_components={
+                StackComponentType.CONTAINER_REGISTRY,
+                StackComponentType.IMAGE_BUILDER,
+            },
+            custom_validation_function=_validate_remote_components,
+        )
+
+    def get_docker_builds(
+        self, deployment: "PipelineDeploymentBase"
+    ) -> List["BuildConfiguration"]:
+        """Get the Docker build configurations for the Modal step operator.
+
+        Args:
+            deployment: The pipeline deployment.
+
+        Returns:
+            A list of Docker build configurations.
+        """
+        builds = []
+        for step_name, step in deployment.step_configurations.items():
+            if step.config.step_operator == self.name:
+                build = BuildConfiguration(
+                    key=MODAL_STEP_OPERATOR_DOCKER_IMAGE_KEY,
+                    settings=step.config.docker_settings,
+                    step_name=step_name,
+                )
+                builds.append(build)
+
+        return builds
+
+    def launch(
+        self,
+        info: "StepRunInfo",
+        entrypoint_command: List[str],
+        environment: Dict[str, str],
+    ) -> None:
+        """Launch a step run on Modal.
+
+        Args:
+            info: The step run information.
+            entrypoint_command: The entrypoint command for the step.
+            environment: The environment variables for the step.
+
+        Raises:
+            RuntimeError: If no Docker credentials are found for the container registry.
+            ValueError: If no container registry is found in the stack.
+        """
+        settings = cast(ModalStepOperatorSettings, self.get_settings(info))
+        image_name = info.get_image(key=MODAL_STEP_OPERATOR_DOCKER_IMAGE_KEY)
+        zc = Client()
+        stack = zc.active_stack
+
+        if not stack.container_registry:
+            raise ValueError(
+                "No Container registry found in the stack. "
+                "Please add a container registry and ensure "
+                "it is correctly configured."
+            )
+
+        if docker_creds := stack.container_registry.credentials:
+            docker_username, docker_password = docker_creds
+        else:
+            raise RuntimeError(
+                "No Docker credentials found for the container registry."
+            )
+
+        my_secret = modal.secret._Secret.from_dict(
+            {
+                "REGISTRY_USERNAME": docker_username,
+                "REGISTRY_PASSWORD": docker_password,
+            }
+        )
+
+        spec = modal.image.DockerfileSpec(
+            commands=[f"FROM {image_name}"], context_files={}
+        )
+
+        zenml_image = modal.Image._from_args(
+            dockerfile_function=lambda *_, **__: spec,
+            force_build=False,
+            image_registry_config=modal.image._ImageRegistryConfig(
+                api_pb2.REGISTRY_AUTH_TYPE_STATIC_CREDS, my_secret
+            ),
+        ).env(environment)
+
+        resource_settings = info.config.resource_settings
+        gpu_values = get_gpu_values(settings, resource_settings)
+
+        app = modal.App(
+            f"zenml-{info.run_name}-{info.step_run_id}-{info.pipeline_step_name}"
+        )
+
+        async def run_sandbox() -> asyncio.Future[None]:
+            loop = asyncio.get_event_loop()
+            future = loop.create_future()
+            with modal.enable_output():
+                async with app.run():
+                    memory_mb = resource_settings.get_memory(ByteUnit.MB)
+                    memory_int = (
+                        int(memory_mb) if memory_mb is not None else None
+                    )
+                    sb = await modal.Sandbox.create.aio(
+                        "bash",
+                        "-c",
+                        " ".join(entrypoint_command),
+                        image=zenml_image,
+                        gpu=gpu_values,
+                        cpu=resource_settings.cpu_count,
+                        memory=memory_int,
+                        cloud=settings.cloud,
+                        region=settings.region,
+                        app=app,
+                        timeout=86400,  # 24h, the max Modal allows
+                    )
+
+                    await sb.wait.aio()
+
+            future.set_result(None)
+            return future
+
+        asyncio.run(run_sandbox())

zenml/orchestrators/step_runner.py

@@ -400,7 +400,7 @@ class StepRunner:
                 **artifact.get_hydrated_version().model_dump()
             )
 
-        if data_type is Any or is_union(get_origin(data_type)):
+        if data_type in (None, Any) or is_union(get_origin(data_type)):
             # Entrypoint function does not define a specific type for the input,
             # we use the datatype of the stored artifact
             data_type = source_utils.load(artifact.data_type)

zenml/orchestrators/utils.py

@@ -40,7 +40,9 @@ if TYPE_CHECKING:
     from zenml.artifact_stores.base_artifact_store import BaseArtifactStore
 
 
-def get_orchestrator_run_name(pipeline_name: str) -> str:
+def get_orchestrator_run_name(
+    pipeline_name: str, max_length: Optional[int] = None
+) -> str:
     """Gets an orchestrator run name.
 
     This run name is not the same as the ZenML run name but can instead be
@@ -48,11 +50,31 @@ def get_orchestrator_run_name(pipeline_name: str) -> str:
 
     Args:
         pipeline_name: Name of the pipeline that will run.
+        max_length: Maximum length of the generated name.
+
+    Raises:
+        ValueError: If the max length is below 8 characters.
 
     Returns:
         The orchestrator run name.
     """
-    return f"{pipeline_name}_{random.Random().getrandbits(128):032x}"
+    suffix_length = 32
+    pipeline_name = f"{pipeline_name}_"
+
+    if max_length:
+        if max_length < 8:
+            raise ValueError(
+                "Maximum length for orchestrator run name must be 8 or above."
+            )
+
+        # Make sure we always have a certain suffix to guarantee no overlap
+        # with other runs
+        suffix_length = min(32, max(8, max_length - len(pipeline_name)))
+        pipeline_name = pipeline_name[: (max_length - suffix_length)]
+
+    suffix = "".join(random.choices("0123456789abcdef", k=suffix_length))
+
+    return f"{pipeline_name}{suffix}"
 
 
 def is_setting_enabled(

{zenml_nightly-0.70.0.dev20241127.dist-info → zenml_nightly-0.70.0.dev20241128.dist-info}/METADATA

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

{zenml_nightly-0.70.0.dev20241127.dist-info → zenml_nightly-0.70.0.dev20241128.dist-info}/RECORD

@@ -6,7 +6,7 @@ RELEASE_NOTES.md,sha256=DleauURHESDrTrcVzCVLqPiSM9NIAk5vldvEFMc7qlk,389375
 ROADMAP.md,sha256=hiLSmr16BH8Dfx7SaQM4JcXCGCVl6mFZPFAwJeDTrJU,407
 SECURITY.md,sha256=9DepA8y03yvCZLHEfcXLTDH4lUyKHquAdukBsccNN7c,682
 zenml/README.md,sha256=827dekbOWAs1BpW7VF1a4d7EbwPbjwccX-2zdXBENZo,1777
-zenml/VERSION,sha256=ABVQIWEjcsl8ujX_CSg3mt4aGfIhe3dLr9X3GJHNxrU,19
+zenml/VERSION,sha256=NNMdj0FLYeBDdXqt2fW55JGAJCyPz22NxDtWUZCXycg,19
 zenml/__init__.py,sha256=SkMObQA41ajqdZqGErN00S1Vf3KAxpLvbZ-OBy5uYoo,2130
 zenml/actions/__init__.py,sha256=mrt6wPo73iKRxK754_NqsGyJ3buW7RnVeIGXr1xEw8Y,681
 zenml/actions/base_action.py,sha256=UcaHev6BTuLDwuswnyaPjdA8AgUqB5xPZ-lRtuvf2FU,25553
@@ -130,7 +130,7 @@ zenml/image_builders/base_image_builder.py,sha256=-Y5N3zFZsMJvVuzm1M3tU-r38fT9KC
 zenml/image_builders/build_context.py,sha256=TTY5T8aG4epeKOOpLItr8PDjmDijfcGaY3zFzmGV1II,6157
 zenml/image_builders/local_image_builder.py,sha256=R_zMpERtUCWLLDZg9kXuAQSWLtin1ve_rxpbUBiym7s,6448
 zenml/integrations/README.md,sha256=hFIZwjsAItHjvDWVBqGSF-ZAeMsFR2GKX1Axl2g1Bz0,6190
-zenml/integrations/__init__.py,sha256=ciJbNsqNPTHpWeMbFfLNa8fJ0jg8AxJUjOPnqrYPl9M,4843
+zenml/integrations/__init__.py,sha256=GiLRzSCu1O9Jg5NSCRKVDWLIXtKuc90ozntqYjUHo08,4905
 zenml/integrations/airflow/__init__.py,sha256=7ffV98vlrdH1RfWHkv8TXNd3hjtXSx4z2U7MZin-87I,1483
 zenml/integrations/airflow/flavors/__init__.py,sha256=Y48mn5OxERPPaXDBd5CFAIn6yhLPsgN5ZMk26hLXiNM,800
 zenml/integrations/airflow/flavors/airflow_orchestrator_flavor.py,sha256=VfZQD2H-WwIgVD1Fi7uewdnkvRoSykY0YCfROFDadXg,6189
@@ -198,7 +198,7 @@ zenml/integrations/comet/experiment_trackers/__init__.py,sha256=reGygyAEgMrlc-9Q
 zenml/integrations/comet/experiment_trackers/comet_experiment_tracker.py,sha256=JnB_TqiCD8t9t6cVxWoomxvBuhA4jIJHYFZ-gKdGXf8,5767
 zenml/integrations/comet/flavors/__init__.py,sha256=x-XK-YwHMxz3zZPoIXo3X5vq_5VYUJAnsIoEX_ZooOU,883
 zenml/integrations/comet/flavors/comet_experiment_tracker_flavor.py,sha256=Rkk1UtEVY2MQBKbUHKxYQpDTWndkOYF8KuKuMGZAb24,3706
-zenml/integrations/constants.py,sha256=Qi3uwS9jIxGY1v4nES-5npWuQTS2uOj6IEUKyOzLehM,2055
+zenml/integrations/constants.py,sha256=hbRRrkXz4qBFFZOl81G_2u7O-gWLU8DTSy43HlyUDUY,2071
 zenml/integrations/databricks/__init__.py,sha256=dkyTxfwIete7mRBlDzIfsTmllYgrd4DB2P4brXHPMUs,2414
 zenml/integrations/databricks/flavors/__init__.py,sha256=S-BZ3R9iKGOw-aUltR8I0ULEe2-LKGTIZhQv9TlnXfk,1122
 zenml/integrations/databricks/flavors/databricks_model_deployer_flavor.py,sha256=eDyYVqO2x1A9qgGICKJx5Z3qiUuTMfW9R3NZUO8OiRk,3591
@@ -337,17 +337,17 @@ zenml/integrations/kubernetes/flavors/__init__.py,sha256=a5gU45qCj3FkLwl_uVjlIkL
 zenml/integrations/kubernetes/flavors/kubernetes_orchestrator_flavor.py,sha256=HkCyDWqv1lDd8W6GeXE6PeHQiUrHPfSkfw3sB0B2xuA,7911
 zenml/integrations/kubernetes/flavors/kubernetes_step_operator_flavor.py,sha256=ILN-H4cl7z3i4ltb4UBs55wbtIo871b4ib28pYkQoyQ,5605
 zenml/integrations/kubernetes/orchestrators/__init__.py,sha256=TJID3OTieZBox36WpQpzD0jdVRA_aZVcs_bNtfXS8ik,811
-zenml/integrations/kubernetes/orchestrators/kube_utils.py,sha256=9PSr1wAR7qGjrtsSrIT00P-5c3eFcVV2tzXzTbH9WOc,10615
-zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator.py,sha256=ElvTfgDEKnhFKLy1TL7v-34Paq9v5rXkXN4Otzonvig,22418
-zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py,sha256=hGvBUnUPhpjudDfumiLLSDsNU2fJR1C-BEPJ671h-VY,6383
+zenml/integrations/kubernetes/orchestrators/kube_utils.py,sha256=0Cj1RoiuXL4oACnfyzEpOiCTnHt_YoF5ml3bhobyOEg,12195
+zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator.py,sha256=W6YpTQXXzQcpfskJcuYwN1LMiN8eUJQHWJ4QXMmADFs,22899
+zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py,sha256=4BBy8-0xJahRjpkFc9fYy90uIRxOoy-s-GmXZeFE2tQ,6442
 zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint_configuration.py,sha256=Y7uGU8eksMluGyXYsf688CwpiXwI_W6WYLscYwRZXRY,2494
-zenml/integrations/kubernetes/orchestrators/manifest_utils.py,sha256=HS8FDu8m9bDFpnmJ5RCe0ZH57F__xqIuo6Fo7wJkL7E,11365
+zenml/integrations/kubernetes/orchestrators/manifest_utils.py,sha256=urcPGUm51vRA1a5eZk2jEGjFrDLPHqD4jTVJDpxngnU,11486
 zenml/integrations/kubernetes/pod_settings.py,sha256=NMp4aHKRG29mh1Nq5uvV78Hzj1cMZj93poWCBiwov-M,4898
 zenml/integrations/kubernetes/serialization_utils.py,sha256=cPSe4szdBLzDnUZT9nQc2CCA8h84aj5oTA8vsUE36ig,7000
 zenml/integrations/kubernetes/service_connectors/__init__.py,sha256=Uf6zlHIapYrRDl3xOPWQ2jA7jt85SXx1U7DmSxzxTvQ,818
 zenml/integrations/kubernetes/service_connectors/kubernetes_service_connector.py,sha256=kgdh25dOBNTxLAFft_cknwHoWRAGrdzUu9fLsm4ZlfY,19579
 zenml/integrations/kubernetes/step_operators/__init__.py,sha256=40utDPYAezxHsFgO0UUIT_6XpCDzDapje6OH951XsTs,806
-zenml/integrations/kubernetes/step_operators/kubernetes_step_operator.py,sha256=sEz8IZkzo0qarnPCr8zarBPHR0T0i6HL8r9nSNHQBxI,8310
+zenml/integrations/kubernetes/step_operators/kubernetes_step_operator.py,sha256=x7-ZO1r85eqOE_RS4IM0H7NGYZcB9okTj6qFrh9N5HM,8376
 zenml/integrations/label_studio/__init__.py,sha256=tXmK0Wu_bFgtL7CqPPubSK99PaBZSyAu90aghHlXAek,1520
 zenml/integrations/label_studio/annotators/__init__.py,sha256=YtOtSfS1_NBoLoXIygEerElBP1-B98UU0HOAEfzdRY0,821
 zenml/integrations/label_studio/annotators/label_studio_annotator.py,sha256=VkuW4zsZhHz8__P9WTTLRTF-FOmoYB-_cFqBdu-PUyA,30498
@@ -396,6 +396,11 @@ zenml/integrations/mlflow/services/mlflow_deployment.py,sha256=iu8u0jQLKNf5oueGP
 zenml/integrations/mlflow/steps/__init__.py,sha256=5IXeipGRfBjtqr0ZdbQLliuQNr5GXsm7xkhpqfOg6qI,770
 zenml/integrations/mlflow/steps/mlflow_deployer.py,sha256=E4A-tiKsVG-GDy1vaiOw37mpa4SzJR3T-HZ6crzONyo,12238
 zenml/integrations/mlflow/steps/mlflow_registry.py,sha256=BeOhuo72ghuJWEIdr4YNqit_ImSljW4suUE9XguFjeQ,6425
+zenml/integrations/modal/__init__.py,sha256=jyIhsLVjxhepKEpO-uyNJ5NSuSqzBIJnhb_lHdHFFFM,1525
+zenml/integrations/modal/flavors/__init__.py,sha256=169Oirq-NUVl-2oiByrMcL3HBM0R971BrS6xVBk0DB4,922
+zenml/integrations/modal/flavors/modal_step_operator_flavor.py,sha256=r7xkzER0hvNY6N0CEZMiF1vRk7A7CfkuYOeGDJ517N4,3978
+zenml/integrations/modal/step_operators/__init__.py,sha256=8NYCXe7aNPnldCI9IjcHzJC_B5e4gtfGzpHNZ-ToKnE,780
+zenml/integrations/modal/step_operators/modal_step_operator.py,sha256=J2HiNaGnlP6kDLBnQKz8mQKaoaQLitFkjHhOP_XRWgI,8543
 zenml/integrations/neptune/__init__.py,sha256=FUaMxVC9uPryIY7reWdzfMcMdsf5T3HjBZ1QjpjEX4Q,1717
 zenml/integrations/neptune/experiment_trackers/__init__.py,sha256=DJi7lk7NXYrRg3VGPPSEsMycKECDfXL-h2V0A0r7z8Y,833
 zenml/integrations/neptune/experiment_trackers/neptune_experiment_tracker.py,sha256=c5CigxkeYGBadcchTOSjZPaDAtAkSzNM9EnaE2dOgc8,3730
@@ -681,9 +686,9 @@ zenml/orchestrators/output_utils.py,sha256=Gz7SX2cbQ3w4eyfU0XuhKEKGtalQGBoc6moDR
 zenml/orchestrators/publish_utils.py,sha256=aNwgTDmVSq9qCDP3Ldk77YNXnWx_YHjYNTEJwYeZo9s,4579
 zenml/orchestrators/step_launcher.py,sha256=HGdshxQAwYHLHa_nJyIkMgrSTbxTQKqI63mKaSQ3ZVg,17758
 zenml/orchestrators/step_run_utils.py,sha256=FjnNGYz8NF-F_WP_8w7Zny0zDd6JanCp3IAFMjKFU9g,19996
-zenml/orchestrators/step_runner.py,sha256=rInaBHdU-43xkho2xW_OlMsAZRVCanry8jRCBveVBpA,25076
+zenml/orchestrators/step_runner.py,sha256=5bRN_0kAj8Jnk0cKt-xGnLrywmbSsqqkcBaJ3jYgDHc,25084
 zenml/orchestrators/topsort.py,sha256=D8evz3X47zwpXd90NMLsJD-_uCeXtV6ClzNfDUrq7cM,5784
-zenml/orchestrators/utils.py,sha256=mW-abfIeLRsprE1Y-wGvURfJzNNtFHMyRrkgX_LEpkw,11446
+zenml/orchestrators/utils.py,sha256=DCKQuAzv9Ba2BxAGeexgCc9Q_1nzbqzhr4B4jI9NbeA,12141
 zenml/orchestrators/wheeled_orchestrator.py,sha256=eOnMcnd3sCzfhA2l6qRAzF0rOXzaojbjvvYvTkqixQo,4791
 zenml/pipelines/__init__.py,sha256=hpIX7hN8jsQRHT5R-xSXZL88qrHwkmrvGLQeu1rWt4o,873
 zenml/pipelines/build_utils.py,sha256=Az-zz56WQqD9dUrZ0iQDDRok-GNeglmXQxv40LoiyQk,25440
@@ -1268,8 +1273,8 @@ zenml/zen_stores/secrets_stores/sql_secrets_store.py,sha256=Bq1djrUP9saoD7vECjS7
 zenml/zen_stores/sql_zen_store.py,sha256=rJT3Uth4J6D1iVfBdNHipgI54jcqIItNVc-IMNEU8Zc,404787
 zenml/zen_stores/template_utils.py,sha256=EKYBgmDLTS_PSMWaIO5yvHPLiQvMqHcsAe6NUCrv-i4,9068
 zenml/zen_stores/zen_store_interface.py,sha256=vf2gKBWfUUPtcGZC35oQB6pPNVzWVyQC8nWxVLjfrxM,92692
-zenml_nightly-0.70.0.dev20241127.dist-info/LICENSE,sha256=wbnfEnXnafPbqwANHkV6LUsPKOtdpsd-SNw37rogLtc,11359
-zenml_nightly-0.70.0.dev20241127.dist-info/METADATA,sha256=KeeoaNmNjtSScsuRqF9RjmRVytjnekiiKvTDU1XaAJY,21208
-zenml_nightly-0.70.0.dev20241127.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-zenml_nightly-0.70.0.dev20241127.dist-info/entry_points.txt,sha256=QK3ETQE0YswAM2mWypNMOv8TLtr7EjnqAFq1br_jEFE,43
-zenml_nightly-0.70.0.dev20241127.dist-info/RECORD,,
+zenml_nightly-0.70.0.dev20241128.dist-info/LICENSE,sha256=wbnfEnXnafPbqwANHkV6LUsPKOtdpsd-SNw37rogLtc,11359
+zenml_nightly-0.70.0.dev20241128.dist-info/METADATA,sha256=pq6OfIPB-gg_Y1RQMZbo2H-G2BX9FLotTfJqywDuYpw,21208
+zenml_nightly-0.70.0.dev20241128.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+zenml_nightly-0.70.0.dev20241128.dist-info/entry_points.txt,sha256=QK3ETQE0YswAM2mWypNMOv8TLtr7EjnqAFq1br_jEFE,43
+zenml_nightly-0.70.0.dev20241128.dist-info/RECORD,,