zenml-nightly 0.81.0.dev20250428__tar.gz → 0.81.0.dev20250429__tar.gz

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: zenml-nightly
-Version: 0.81.0.dev20250428
+Version: 0.81.0.dev20250429
 Summary: ZenML: Write production-ready ML code.
 License: Apache-2.0
 Keywords: machine learning,production,pipeline,mlops,devops
@@ -110,7 +110,7 @@ Requires-Dist: requests (>=2.27.11,<3.0.0) ; extra == "connectors-azure"
 Requires-Dist: rich[jupyter] (>=12.0.0)
 Requires-Dist: ruff (>=0.1.7) ; extra == "templates" or extra == "dev"
 Requires-Dist: s3fs (>=2022.11.0,!=2025.3.1) ; extra == "s3fs"
-Requires-Dist: sagemaker (>=2.199.0) ; extra == "sagemaker"
+Requires-Dist: sagemaker (>=2.237.3) ; extra == "sagemaker"
 Requires-Dist: secure (>=0.3.0,<0.4.0) ; extra == "server"
 Requires-Dist: setuptools
 Requires-Dist: sqlalchemy (>=2.0.0,<3.0.0)

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zenml-nightly"
-version = "0.81.0.dev20250428"
+version = "0.81.0.dev20250429"
 packages = [{ include = "zenml", from = "src" }]
 description = "ZenML: Write production-ready ML code."
 authors = ["ZenML GmbH <info@zenml.io>"]
@@ -117,7 +117,7 @@ azure-mgmt-resource = { version = ">=21.0.0", optional = true }
 s3fs = { version = ">=2022.11.0,!=2025.3.1", optional = true }
 
 # Optional dependencies for the Sagemaker orchestrator
-sagemaker = { version = ">=2.199.0", optional = true }
+sagemaker = { version = ">=2.237.3", optional = true }
 
 # Optional dependencies for the GCS artifact store
 gcsfs = { version = ">=2022.11.0", optional = true }

zenml_nightly-0.81.0.dev20250429/src/zenml/VERSION

@@ -0,0 +1 @@
+0.81.0.dev20250429

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/config/build_configuration.py

@@ -95,6 +95,10 @@ class BuildConfiguration(BaseModel):
         for _, requirements, _ in requirements_files:
             hash_.update(requirements.encode())
 
+        if self.settings.dockerfile:
+            with open(self.settings.dockerfile, "rb") as f:
+                hash_.update(f.read())
+
         return hash_.hexdigest()
 
     def should_include_files(

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/entrypoints/base_entrypoint_configuration.py

@@ -274,7 +274,7 @@ class BaseEntrypointConfiguration(ABC):
         download_dir = os.path.join(
             code_repo_root, code_reference.subdirectory
         )
-        os.makedirs(download_dir)
+        os.makedirs(download_dir, exist_ok=True)
         repo.download_files(
             commit=code_reference.commit,
             directory=download_dir,

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/environment.py

@@ -15,12 +15,10 @@
 
 import os
 import platform
-from pathlib import Path
 from typing import Dict
 
 import distro
 
-from zenml import __version__
 from zenml.constants import INSIDE_ZENML_CONTAINER
 from zenml.enums import EnvironmentType
 from zenml.logger import get_logger
@@ -88,35 +86,8 @@ def get_environment() -> str:
         return EnvironmentType.NATIVE
 
 
-def get_system_details() -> str:
-    """Returns OS, python and ZenML information.
-
-    Returns:
-        str: OS, python and ZenML information
-    """
-    from zenml.integrations.registry import integration_registry
-
-    info = {
-        "ZenML version": __version__,
-        "Install path": Path(__file__).resolve().parent,
-        "Python version": Environment.python_version(),
-        "Platform information": Environment.get_system_info(),
-        "Environment": get_environment(),
-        "Integrations": integration_registry.get_installed_integrations(),
-    }
-    return "\n".join(
-        "{:>10} {}".format(k + ":", str(v).replace("\n", " "))
-        for k, v in info.items()
-    )
-
-
 class Environment(metaclass=SingletonMetaClass):
-    """Provides environment information.
-
-    Individual environment components can be registered separately to extend
-    the global Environment object with additional information (see
-    `BaseEnvironmentComponent`).
-    """
+    """Provides environment information."""
 
     def __init__(self) -> None:
         """Initializes an Environment instance.

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/exceptions.py

@@ -70,40 +70,6 @@ class DoesNotExistException(ZenMLBaseException):
         super().__init__(message)
 
 
-class PipelineNotSucceededException(ZenMLBaseException):
-    """Raises exception when trying to fetch artifacts from a not succeeded pipeline."""
-
-    def __init__(
-        self,
-        name: str = "",
-        message: str = "{} is not yet completed successfully.",
-    ):
-        """Initializes the exception.
-
-        Args:
-            name: Name of the pipeline.
-            message: Message with details of exception.
-        """
-        super().__init__(message.format(name))
-
-
-class GitException(ZenMLBaseException):
-    """Raises exception when a problem occurs in git resolution."""
-
-    def __init__(
-        self,
-        message: str = "There is a problem with git resolution. "
-        "Please make sure that all relevant files "
-        "are committed.",
-    ):
-        """Initializes the exception.
-
-        Args:
-            message: Message with details of exception.
-        """
-        super().__init__(message)
-
-
 class StepInterfaceError(ZenMLBaseException):
     """Raises exception when interacting with the Step interface in an unsupported way."""
 
@@ -116,50 +82,18 @@ class StepContextError(ZenMLBaseException):
     """Raises exception when interacting with a StepContext in an unsupported way."""
 
 
-class PipelineInterfaceError(ZenMLBaseException):
-    """Raises exception when interacting with the Pipeline interface in an unsupported way."""
-
-
-class ArtifactInterfaceError(ZenMLBaseException):
-    """Raises exception when interacting with the Artifact interface in an unsupported way."""
-
-
 class StackComponentInterfaceError(ZenMLBaseException):
     """Raises exception when interacting with the stack components in an unsupported way."""
 
 
-class StackComponentDeploymentError(ZenMLBaseException):
-    """Raises exception when deploying a stack component fails."""
-
-
 class ArtifactStoreInterfaceError(ZenMLBaseException):
     """Raises exception when interacting with the Artifact Store interface in an unsupported way."""
 
 
-class PipelineConfigurationError(ZenMLBaseException):
-    """Raises exceptions when a pipeline configuration contains invalid values."""
-
-
 class IntegrationError(ZenMLBaseException):
     """Raises exceptions when a requested integration can not be activated."""
 
 
-class DuplicateRunNameError(RuntimeError):
-    """Raises exception when a run with the same name already exists."""
-
-    def __init__(
-        self,
-        message: str = "Unable to run a pipeline with a run name that "
-        "already exists.",
-    ):
-        """Initializes the exception.
-
-        Args:
-            message: Message with details of exception.
-        """
-        super().__init__(message)
-
-
 class ValidationError(ZenMLBaseException):
     """Raised when the Model passed to the ZenStore."""
 
@@ -180,22 +114,10 @@ class StackValidationError(ZenMLBaseException):
     """Raised when a stack configuration is not valid."""
 
 
-class StackComponentValidationError(ZenMLBaseException):
-    """Raised when a stack component configuration is not valid."""
-
-
-class ProvisioningError(ZenMLBaseException):
-    """Raised when an error occurs when provisioning resources for a StackComponent."""
-
-
 class GitNotFoundError(ImportError):
     """Raised when ZenML CLI is used to interact with examples on a machine with no git installation."""
 
 
-class DuplicatedConfigurationError(ZenMLBaseException):
-    """Raised when a configuration parameter is set twice."""
-
-
 class IllegalOperationError(ZenMLBaseException):
     """Raised when an illegal operation is attempted."""
 

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/aws/__init__.py

@@ -41,7 +41,7 @@ class AWSIntegration(Integration):
 
     NAME = AWS
     REQUIREMENTS = [
-        "sagemaker>=2.199.0",
+        "sagemaker>=2.237.3",
         "kubernetes",
         "aws-profile-manager",
     ]

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/evidently/__init__.py

@@ -56,6 +56,7 @@ class EvidentlyIntegration(Integration):
     REQUIREMENTS = [
         "evidently>=0.4.16,<=0.4.22",
         "tenacity!=8.4.0",  # https://github.com/jd/tenacity/issues/471
+        "numpy<2.0.0",  # evidently is not compatible with NumPy 2.0
     ]
     REQUIREMENTS_IGNORED_ON_UNINSTALL = ["tenacity", "pandas"]
 

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/gcp/flavors/vertex_orchestrator_flavor.py

@@ -112,6 +112,11 @@ class VertexOrchestratorConfig(
         network: the full name of the Compute Engine Network to which the job
             should be peered. For example, `projects/12345/global/networks/myVPC`
             If not provided, the job will not be peered with any network.
+        private_service_connect: the full name of a Private Service Connect
+            endpoint to which the job should be peered. For example,
+            `projects/12345/regions/us-central1/networkAttachments/NETWORK_ATTACHMENT_NAME`
+            If not provided, the job will not be peered with any private service
+            connect endpoint.
         cpu_limit: The maximum CPU limit for this operator. This string value
             can be a number (integer value for number of CPUs) as string,
             or a number followed by "m", which means 1/1000. You can specify
@@ -130,6 +135,7 @@ class VertexOrchestratorConfig(
     encryption_spec_key_name: Optional[str] = None
     workload_service_account: Optional[str] = None
     network: Optional[str] = None
+    private_service_connect: Optional[str] = None
 
     # Deprecated
     cpu_limit: Optional[str] = None

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/gcp/orchestrators/vertex_orchestrator.py

@@ -48,7 +48,15 @@ from uuid import UUID
 
 from google.api_core import exceptions as google_exceptions
 from google.cloud import aiplatform
+from google.cloud.aiplatform.compat.services import (
+    pipeline_service_client_v1beta1,
+)
+from google.cloud.aiplatform.compat.types import pipeline_job_v1beta1
 from google.cloud.aiplatform_v1.types import PipelineState
+from google.cloud.aiplatform_v1beta1.types.service_networking import (
+    PscInterfaceConfig,
+)
+from google.protobuf import json_format
 from google_cloud_pipeline_components.v1.custom_job.utils import (
     create_custom_training_job_from_component,
 )
@@ -495,36 +503,16 @@ class VertexOrchestrator(ContainerizedOrchestrator, GoogleCredentialsMixin):
                 )
                 pod_settings = step_settings.pod_settings
                 if pod_settings:
-                    if pod_settings.host_ipc:
-                        logger.warning(
-                            "Host IPC is set to `True` but not supported in "
-                            "this orchestrator. Ignoring..."
-                        )
-                    if pod_settings.affinity:
-                        logger.warning(
-                            "Affinity is set but not supported in Vertex with "
-                            "Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.tolerations:
-                        logger.warning(
-                            "Tolerations are set but not supported in "
-                            "Vertex with Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.volumes:
-                        logger.warning(
-                            "Volumes are set but not supported in Vertex with "
-                            "Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.volume_mounts:
-                        logger.warning(
-                            "Volume mounts are set but not supported in "
-                            "Vertex with Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.env or pod_settings.env_from:
+                    ignored_fields = pod_settings.model_fields_set - {
+                        "node_selectors"
+                    }
+                    if ignored_fields:
                         logger.warning(
-                            "Environment variables are set but not supported "
-                            "in Vertex with Vertex Pipelines 2.x. Ignoring..."
+                            f"The following pod settings are not supported in "
+                            f"Vertex with Vertex Pipelines 2.x and will be "
+                            f"ignored: {list(ignored_fields)}."
                         )
+
                     for key in pod_settings.node_selectors:
                         if (
                             key
@@ -737,6 +725,39 @@ class VertexOrchestrator(ContainerizedOrchestrator, GoogleCredentialsMixin):
                 self.config.network,
             )
 
+        if self.config.private_service_connect:
+            # The PSC setting isn't yet part of the stable v1 API. We need to
+            # temporarily hack the aiplatform.PipelineJob object in two places:
+            # * to use the v1beta1 PipelineJob primitive which supports the
+            #   psc_interface_config field instead of the v1 PipelineJob
+            #   primitive.
+            # * to use the v1beta1 PipelineServiceClient instead of the v1
+            #   PipelineServiceClient.
+            #
+            # We achieve the first by converting the v1 PipelineJob to a
+            # v1beta1 PipelineJob and the second by replacing the v1
+            # PipelineServiceClient with a v1beta1 PipelineServiceClient.
+            #
+            # TODO: Remove this once the v1 stable API is updated to support
+            # the PSC setting.
+            pipeline_job_dict = json_format.MessageToDict(
+                run._gca_resource._pb, preserving_proto_field_name=True
+            )
+            run._gca_resource = pipeline_job_v1beta1.PipelineJob(
+                **pipeline_job_dict,
+                psc_interface_config=PscInterfaceConfig(
+                    network_attachment=self.config.private_service_connect,
+                ),
+            )
+            run.api_client = (
+                pipeline_service_client_v1beta1.PipelineServiceClient(
+                    credentials=run.credentials,
+                    client_options={
+                        "api_endpoint": run.api_client.api_endpoint,
+                    },
+                )
+            )
+
         try:
             if schedule:
                 logger.info(

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/kubeflow/orchestrators/kubeflow_orchestrator.py

@@ -555,36 +555,14 @@ class KubeflowOrchestrator(ContainerizedOrchestrator):
                 )
                 pod_settings = step_settings.pod_settings
                 if pod_settings:
-                    if pod_settings.host_ipc:
+                    ignored_fields = pod_settings.model_fields_set - {
+                        "node_selectors"
+                    }
+                    if ignored_fields:
                         logger.warning(
-                            "Host IPC is set to `True` but not supported in "
-                            "this orchestrator. Ignoring..."
-                        )
-                    if pod_settings.affinity:
-                        logger.warning(
-                            "Affinity is set but not supported in Kubeflow with "
-                            "Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.tolerations:
-                        logger.warning(
-                            "Tolerations are set but not supported in "
-                            "Kubeflow with Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.volumes:
-                        logger.warning(
-                            "Volumes are set but not supported in Kubeflow with "
-                            "Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.volume_mounts:
-                        logger.warning(
-                            "Volume mounts are set but not supported in "
-                            "Kubeflow with Kubeflow Pipelines 2.x. Ignoring..."
-                        )
-                    if pod_settings.env or pod_settings.env_from:
-                        logger.warning(
-                            "Environment variables are set but not supported "
-                            "in Kubeflow with Kubeflow Pipelines 2.x. "
-                            "Ignoring..."
+                            f"The following pod settings are not supported in "
+                            f"Kubeflow with Kubeflow Pipelines 2.x and will be "
+                            f"ignored: {list(ignored_fields)}."
                         )
 
                     # apply pod settings

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/kubernetes/flavors/kubernetes_orchestrator_flavor.py

@@ -15,6 +15,8 @@
 
 from typing import TYPE_CHECKING, Optional, Type
 
+from pydantic import PositiveInt
+
 from zenml.config.base_settings import BaseSettings
 from zenml.constants import KUBERNETES_CLUSTER_RESOURCE_TYPE
 from zenml.integrations.kubernetes import KUBERNETES_ORCHESTRATOR_FLAVOR
@@ -47,6 +49,7 @@ class KubernetesOrchestratorSettings(BaseSettings):
         pod_settings: Pod settings to apply to pods executing the steps.
         orchestrator_pod_settings: Pod settings to apply to the pod which is
             launching the actual steps.
+        pod_name_prefix: Prefix to use for the pod name.
         pod_startup_timeout: The maximum time to wait for a pending step pod to
             start (in seconds).
         pod_failure_max_retries: The maximum number of times to retry a step
@@ -55,6 +58,7 @@ class KubernetesOrchestratorSettings(BaseSettings):
             failure retries and pod startup retries (in seconds)
         pod_failure_backoff: The backoff factor for pod failure retries and
             pod startup retries.
+        max_parallelism: Maximum number of steps to run in parallel.
     """
 
     synchronous: bool = True
@@ -64,10 +68,12 @@ class KubernetesOrchestratorSettings(BaseSettings):
     privileged: bool = False
     pod_settings: Optional[KubernetesPodSettings] = None
     orchestrator_pod_settings: Optional[KubernetesPodSettings] = None
+    pod_name_prefix: Optional[str] = None
     pod_startup_timeout: int = 60 * 10  # Default 10 minutes
     pod_failure_max_retries: int = 3
     pod_failure_retry_delay: int = 10
     pod_failure_backoff: float = 1.0
+    max_parallelism: Optional[PositiveInt] = None
 
 
 class KubernetesOrchestratorConfig(

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator.py

@@ -417,6 +417,9 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
                 )
 
         pipeline_name = deployment.pipeline_configuration.name
+        settings = cast(
+            KubernetesOrchestratorSettings, self.get_settings(deployment)
+        )
 
         # 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
@@ -427,8 +430,16 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
         orchestrator_run_name = get_orchestrator_run_name(
             pipeline_name, max_length=max_length
         )
+
+        if settings.pod_name_prefix:
+            pod_name = get_orchestrator_run_name(
+                settings.pod_name_prefix, max_length=max_length
+            )
+        else:
+            pod_name = orchestrator_run_name
+
         pod_name = kube_utils.sanitize_pod_name(
-            orchestrator_run_name, namespace=self.config.kubernetes_namespace
+            pod_name, namespace=self.config.kubernetes_namespace
         )
 
         assert stack.container_registry
@@ -455,10 +466,6 @@ class KubernetesOrchestrator(ContainerizedOrchestrator):
             run_id=placeholder_run.id if placeholder_run else None,
         )
 
-        settings = cast(
-            KubernetesOrchestratorSettings, self.get_settings(deployment)
-        )
-
         # Authorize pod to run Kubernetes commands inside the cluster.
         service_account_name = self._get_service_account_name(settings)
 

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/kubernetes/orchestrators/kubernetes_orchestrator_entrypoint.py

@@ -15,7 +15,7 @@
 
 import argparse
 import socket
-from typing import Any, Dict
+from typing import Any, Dict, cast
 from uuid import UUID
 
 from kubernetes import client as k8s_client
@@ -41,7 +41,10 @@ from zenml.integrations.kubernetes.orchestrators.manifest_utils import (
 from zenml.logger import get_logger
 from zenml.orchestrators import publish_utils
 from zenml.orchestrators.dag_runner import NodeStatus, ThreadedDagRunner
-from zenml.orchestrators.utils import get_config_environment_vars
+from zenml.orchestrators.utils import (
+    get_config_environment_vars,
+    get_orchestrator_run_name,
+)
 
 logger = get_logger(__name__)
 
@@ -103,8 +106,27 @@ def main() -> None:
         Raises:
             Exception: If the pod fails to start.
         """
-        # Define Kubernetes pod name.
-        pod_name = f"{orchestrator_run_id}-{step_name}"
+        step_config = deployment_config.step_configurations[step_name].config
+        settings = step_config.settings.get("orchestrator.kubernetes", None)
+        settings = KubernetesOrchestratorSettings.model_validate(
+            settings.model_dump() if settings else {}
+        )
+
+        if settings.pod_name_prefix and not orchestrator_run_id.startswith(
+            settings.pod_name_prefix
+        ):
+            max_length = (
+                kube_utils.calculate_max_pod_name_length_for_namespace(
+                    namespace=args.kubernetes_namespace
+                )
+            )
+            pod_name_prefix = get_orchestrator_run_name(
+                settings.pod_name_prefix, max_length=max_length
+            )
+            pod_name = f"{pod_name_prefix}-{step_name}"
+        else:
+            pod_name = f"{orchestrator_run_id}-{step_name}"
+
         pod_name = kube_utils.sanitize_pod_name(
             pod_name, namespace=args.kubernetes_namespace
         )
@@ -116,20 +138,6 @@ def main() -> None:
             step_name=step_name, deployment_id=deployment_config.id
         )
 
-        step_config = deployment_config.step_configurations[step_name].config
-
-        kubernetes_settings = step_config.settings.get(
-            "orchestrator.kubernetes", None
-        )
-
-        orchestrator_settings = {}
-        if kubernetes_settings is not None:
-            orchestrator_settings = kubernetes_settings.model_dump()
-
-        settings = KubernetesOrchestratorSettings.model_validate(
-            orchestrator_settings
-        )
-
         # We set some default minimum memory resource requests for the step pod
         # here if the user has not specified any, because the step pod takes up
         # some memory resources itself and, if not specified, the pod will be
@@ -274,12 +282,17 @@ def main() -> None:
     parallel_node_startup_waiting_period = (
         orchestrator.config.parallel_step_startup_waiting_period or 0.0
     )
+    settings = cast(
+        KubernetesOrchestratorSettings,
+        orchestrator.get_settings(deployment_config),
+    )
     try:
         ThreadedDagRunner(
             dag=pipeline_dag,
             run_fn=run_step_on_kubernetes,
             finalize_fn=finalize_run,
             parallel_node_startup_waiting_period=parallel_node_startup_waiting_period,
+            max_parallelism=settings.max_parallelism,
         ).run()
         logger.info("Orchestration pod completed.")
     finally:

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/kubernetes/orchestrators/manifest_utils.py

@@ -28,6 +28,9 @@ from zenml.integrations.airflow.orchestrators.dag_generator import (
 )
 from zenml.integrations.kubernetes.orchestrators import kube_utils
 from zenml.integrations.kubernetes.pod_settings import KubernetesPodSettings
+from zenml.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 def add_local_stores_mount(
@@ -244,6 +247,24 @@ def add_pod_settings(
     if settings.host_ipc:
         pod_spec.host_ipc = settings.host_ipc
 
+    if settings.scheduler_name:
+        pod_spec.scheduler_name = settings.scheduler_name
+
+    for key, value in settings.additional_pod_spec_args.items():
+        if not hasattr(pod_spec, key):
+            logger.warning(f"Ignoring invalid Pod Spec argument `{key}`.")
+        else:
+            if value is None:
+                continue
+
+            existing_value = getattr(pod_spec, key)
+            if isinstance(existing_value, list):
+                existing_value.extend(value)
+            elif isinstance(existing_value, dict):
+                existing_value.update(value)
+            else:
+                setattr(pod_spec, key, value)
+
 
 def build_cron_job_manifest(
     cron_expression: str,

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/kubernetes/pod_settings.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Kubernetes pod settings."""
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
 from pydantic import field_validator
 
@@ -33,10 +33,13 @@ class KubernetesPodSettings(BaseSettings):
         volumes: Volumes to mount in the pod.
         volume_mounts: Volume mounts to apply to the pod containers.
         host_ipc: Whether to enable host IPC for the pod.
+        scheduler_name: The name of the scheduler to use for the pod.
         image_pull_secrets: Image pull secrets to use for the pod.
         labels: Labels to apply to the pod.
         env: Environment variables to apply to the container.
         env_from: Environment variables to apply to the container.
+        additional_pod_spec_args: Additional arguments to pass to the pod. These
+            will be applied to the pod spec.
     """
 
     node_selectors: Dict[str, str] = {}
@@ -47,10 +50,12 @@ class KubernetesPodSettings(BaseSettings):
     volumes: List[Dict[str, Any]] = []
     volume_mounts: List[Dict[str, Any]] = []
     host_ipc: bool = False
+    scheduler_name: Optional[str] = None
     image_pull_secrets: List[str] = []
     labels: Dict[str, str] = {}
     env: List[Dict[str, Any]] = []
     env_from: List[Dict[str, Any]] = []
+    additional_pod_spec_args: Dict[str, Any] = {}
 
     @field_validator("volumes", mode="before")
     @classmethod

{zenml_nightly-0.81.0.dev20250428 → zenml_nightly-0.81.0.dev20250429}/src/zenml/integrations/numpy/__init__.py

@@ -21,7 +21,10 @@ class NumpyIntegration(Integration):
     """Definition of Numpy integration for ZenML."""
 
     NAME = NUMPY
-    REQUIREMENTS = ["numpy<2.0.0"]
+    # Support both NumPy 1.x and 2.x
+    # Note: Some other integrations (like evidently) may require NumPy <2.0
+    # until they are updated for NumPy 2.0 compatibility
+    REQUIREMENTS = ["numpy<3.0"]
 
     @classmethod
     def activate(cls) -> None: