zenml-nightly 0.62.0.dev20240726__tar.gz → 0.62.0.dev20240727__tar.gz

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/PKG-INFO

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

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zenml-nightly"
-version = "0.62.0.dev20240726"
+version = "0.62.0.dev20240727"
 packages = [{ include = "zenml", from = "src" }]
 description = "ZenML: Write production-ready ML code."
 authors = ["ZenML GmbH <info@zenml.io>"]
@@ -341,7 +341,6 @@ exclude = [
 # Disable autofix for unused imports (`F401`).
 unfixable = ["F401"]
 per-file-ignores = {}
-ignore-init-module-imports = true
 ignore = [
     "E501",
     "F401",

zenml_nightly-0.62.0.dev20240727/src/zenml/VERSION

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

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/src/zenml/config/pipeline_spec.py

@@ -16,7 +16,7 @@
 import json
 from typing import Any, Dict, List, Optional
 
-from zenml.config.source import Source
+from zenml.config.source import Source, SourceWithValidator
 from zenml.config.step_configurations import StepSpec
 from zenml.config.strict_base_model import StrictBaseModel
 from zenml.utils.json_utils import pydantic_encoder
@@ -34,7 +34,7 @@ class PipelineSpec(StrictBaseModel):
     # - 0.4: New Pipeline class, the upstream steps and
     #   inputs in the step specs refer to the pipeline parameter names
     version: str = "0.4"
-    source: Optional[Source] = None
+    source: Optional[SourceWithValidator] = None
     parameters: Dict[str, Any] = {}
     steps: List[StepSpec]
 

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/src/zenml/config/step_configurations.py

@@ -55,10 +55,10 @@ logger = get_logger(__name__)
 class PartialArtifactConfiguration(StrictBaseModel):
     """Class representing a partial input/output artifact configuration."""
 
-    materializer_source: Optional[Tuple[Source, ...]] = None
+    materializer_source: Optional[Tuple[SourceWithValidator, ...]] = None
     # TODO: This could be moved to the `PipelineDeployment` as it's the same
     # for all steps/outputs
-    default_materializer_source: Optional[Source] = None
+    default_materializer_source: Optional[SourceWithValidator] = None
 
     @model_validator(mode="before")
     @classmethod
@@ -109,7 +109,7 @@ class PartialArtifactConfiguration(StrictBaseModel):
 class ArtifactConfiguration(PartialArtifactConfiguration):
     """Class representing a complete input/output artifact configuration."""
 
-    materializer_source: Tuple[Source, ...]
+    materializer_source: Tuple[SourceWithValidator, ...]
 
     @field_validator("materializer_source", mode="before")
     @classmethod

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/src/zenml/integrations/gcp/orchestrators/vertex_orchestrator.py

@@ -363,7 +363,6 @@ class VertexOrchestrator(ContainerizedOrchestrator, GoogleCredentialsMixin):
                 pipeline_func
             """
             step_name_to_dynamic_component: Dict[str, Any] = {}
-            node_selector_constraint: Optional[Tuple[str, str]] = None
 
             for step_name, step in deployment.step_configurations.items():
                 image = self.get_image(
@@ -410,23 +409,17 @@ class VertexOrchestrator(ContainerizedOrchestrator, GoogleCredentialsMixin):
                             "Volume mounts are set but not supported in "
                             "Vertex with Kubeflow Pipelines 2.x. Ignoring..."
                         )
-
-                    # apply pod settings
-                    if (
-                        GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL
-                        in pod_settings.node_selectors.keys()
-                    ):
-                        node_selector_constraint = (
-                            GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL,
-                            pod_settings.node_selectors[
-                                GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL
-                            ],
-                        )
-                    elif step_settings.node_selector_constraint:
-                        node_selector_constraint = (
-                            GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL,
-                            step_settings.node_selector_constraint[1],
-                        )
+                    for key in pod_settings.node_selectors:
+                        if (
+                            key
+                            != GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL
+                        ):
+                            logger.warning(
+                                "Vertex only allows the %s node selector, "
+                                "ignoring the node selector %s.",
+                                GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL,
+                                key,
+                            )
 
                 step_name_to_dynamic_component[step_name] = dynamic_component
 
@@ -460,10 +453,33 @@ class VertexOrchestrator(ContainerizedOrchestrator, GoogleCredentialsMixin):
                         )
                         .after(*upstream_step_components)
                     )
+
+                    step_settings = cast(
+                        VertexOrchestratorSettings, self.get_settings(step)
+                    )
+                    pod_settings = step_settings.pod_settings
+
+                    node_selector_constraint: Optional[Tuple[str, str]] = None
+                    if pod_settings and (
+                        GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL
+                        in pod_settings.node_selectors.keys()
+                    ):
+                        node_selector_constraint = (
+                            GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL,
+                            pod_settings.node_selectors[
+                                GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL
+                            ],
+                        )
+                    elif step_settings.node_selector_constraint:
+                        node_selector_constraint = (
+                            GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL,
+                            step_settings.node_selector_constraint[1],
+                        )
+
                     self._configure_container_resources(
-                        task,
-                        step.config.resource_settings,
-                        node_selector_constraint,
+                        dynamic_component=task,
+                        resource_settings=step.config.resource_settings,
+                        node_selector_constraint=node_selector_constraint,
                     )
 
             return dynamic_pipeline
@@ -731,20 +747,20 @@ class VertexOrchestrator(ContainerizedOrchestrator, GoogleCredentialsMixin):
         )
 
         if node_selector_constraint:
-            (constraint_label, value) = node_selector_constraint
+            _, value = node_selector_constraint
             if gpu_limit is not None and gpu_limit > 0:
                 dynamic_component = (
                     dynamic_component.set_accelerator_type(value)
                     .set_accelerator_limit(gpu_limit)
                     .set_gpu_limit(gpu_limit)
                 )
-            elif (
-                constraint_label
-                == GKE_ACCELERATOR_NODE_SELECTOR_CONSTRAINT_LABEL
-                and gpu_limit == 0
-            ):
+            else:
                 logger.warning(
-                    "GPU limit is set to 0 but a GPU type is specified. Ignoring GPU settings."
+                    "Accelerator type %s specified, but the GPU limit is not "
+                    "set or set to 0. The accelerator type will be ignored. "
+                    "To fix this warning, either remove the specified "
+                    "accelerator type or set the `gpu_count` using the "
+                    "ResourceSettings (https://docs.zenml.io/how-to/training-with-gpus#specify-resource-requirements-for-steps)."
                 )
 
         return dynamic_component

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/src/zenml/integrations/kubernetes/__init__.py

@@ -24,6 +24,7 @@ from zenml.integrations.integration import Integration
 from zenml.stack import Flavor
 
 KUBERNETES_ORCHESTRATOR_FLAVOR = "kubernetes"
+KUBERNETES_STEP_OPERATOR_FLAVOR = "kubernetes"
 
 
 class KubernetesIntegration(Integration):
@@ -42,10 +43,10 @@ class KubernetesIntegration(Integration):
             List of new stack component flavors.
         """
         from zenml.integrations.kubernetes.flavors import (
-            KubernetesOrchestratorFlavor,
+            KubernetesOrchestratorFlavor, KubernetesStepOperatorFlavor
         )
 
-        return [KubernetesOrchestratorFlavor]
+        return [KubernetesOrchestratorFlavor, KubernetesStepOperatorFlavor]
 
 
 KubernetesIntegration.check_installation()

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/src/zenml/integrations/kubernetes/flavors/__init__.py

@@ -18,9 +18,17 @@ from zenml.integrations.kubernetes.flavors.kubernetes_orchestrator_flavor import
     KubernetesOrchestratorFlavor,
     KubernetesOrchestratorSettings,
 )
+from zenml.integrations.kubernetes.flavors.kubernetes_step_operator_flavor import (
+    KubernetesStepOperatorConfig,
+    KubernetesStepOperatorFlavor,
+    KubernetesStepOperatorSettings,
+)
 
 __all__ = [
     "KubernetesOrchestratorFlavor",
     "KubernetesOrchestratorConfig",
     "KubernetesOrchestratorSettings",
+    "KubernetesStepOperatorConfig",
+    "KubernetesStepOperatorFlavor",
+    "KubernetesStepOperatorSettings",
 ]

zenml_nightly-0.62.0.dev20240727/src/zenml/integrations/kubernetes/flavors/kubernetes_step_operator_flavor.py

@@ -0,0 +1,166 @@
+#  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.
+"""Kubernetes step operator flavor."""
+
+from typing import TYPE_CHECKING, Optional, Type
+
+from zenml.config.base_settings import BaseSettings
+from zenml.constants import KUBERNETES_CLUSTER_RESOURCE_TYPE
+from zenml.integrations.kubernetes import KUBERNETES_STEP_OPERATOR_FLAVOR
+from zenml.integrations.kubernetes.pod_settings import KubernetesPodSettings
+from zenml.models import ServiceConnectorRequirements
+from zenml.step_operators import BaseStepOperatorConfig, BaseStepOperatorFlavor
+
+if TYPE_CHECKING:
+    from zenml.integrations.kubernetes.step_operators import (
+        KubernetesStepOperator,
+    )
+
+
+class KubernetesStepOperatorSettings(BaseSettings):
+    """Settings for the Kubernetes step operator.
+
+    Attributes:
+        pod_settings: Pod settings to apply to pods executing the steps.
+        service_account_name: Name of the service account to use for the pod.
+        privileged: If the container should be run in privileged mode.
+    """
+
+    pod_settings: Optional[KubernetesPodSettings] = None
+    service_account_name: Optional[str] = None
+    privileged: bool = False
+
+
+class KubernetesStepOperatorConfig(
+    BaseStepOperatorConfig, KubernetesStepOperatorSettings
+):
+    """Configuration for the Kubernetes step operator.
+
+    Attributes:
+        kubernetes_namespace: Name of the Kubernetes namespace to be used.
+        incluster: If `True`, the step operator will run the pipeline inside the
+            same cluster in which the orchestrator is running. For this to work,
+            the pod running the orchestrator needs permissions to create new
+            pods. If set, the `kubernetes_context` config option is ignored. If
+            the stack component is linked to a Kubernetes service connector,
+            this field is ignored.
+        kubernetes_context: Name of a Kubernetes context to run pipelines in.
+            If the stack component is linked to a Kubernetes service connector,
+            this field is ignored. Otherwise, it is mandatory.
+    """
+
+    kubernetes_namespace: str = "zenml"
+    incluster: bool = False
+    kubernetes_context: Optional[str] = None
+
+    @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
+
+    @property
+    def is_local(self) -> bool:
+        """Checks if this stack component is running locally.
+
+        Returns:
+            True if this config is for a local component, False otherwise.
+        """
+        return False
+
+
+class KubernetesStepOperatorFlavor(BaseStepOperatorFlavor):
+    """Kubernetes step operator flavor."""
+
+    @property
+    def name(self) -> str:
+        """Name of the flavor.
+
+        Returns:
+            The name of the flavor.
+        """
+        return KUBERNETES_STEP_OPERATOR_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/step_operator/kubernetes.png"
+
+    @property
+    def config_class(self) -> Type[KubernetesStepOperatorConfig]:
+        """Returns `KubernetesStepOperatorConfig` config class.
+
+        Returns:
+                The config class.
+        """
+        return KubernetesStepOperatorConfig
+
+    @property
+    def implementation_class(self) -> Type["KubernetesStepOperator"]:
+        """Implementation class for this flavor.
+
+        Returns:
+            The implementation class.
+        """
+        from zenml.integrations.kubernetes.step_operators import (
+            KubernetesStepOperator,
+        )
+
+        return KubernetesStepOperator

zenml_nightly-0.62.0.dev20240727/src/zenml/integrations/kubernetes/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.
+"""Kubernetes step operator."""
+
+from zenml.integrations.kubernetes.step_operators.kubernetes_step_operator  import (
+    KubernetesStepOperator,
+)
+
+__all__ = [
+    "KubernetesStepOperator",
+]

zenml_nightly-0.62.0.dev20240727/src/zenml/integrations/kubernetes/step_operators/kubernetes_step_operator.py

@@ -0,0 +1,235 @@
+#  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.
+"""Kubernetes step operator implementation."""
+
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Type, cast
+
+from kubernetes import client as k8s_client
+
+from zenml.config.base_settings import BaseSettings
+from zenml.config.build_configuration import BuildConfiguration
+from zenml.enums import StackComponentType
+from zenml.integrations.kubernetes.flavors import (
+    KubernetesStepOperatorConfig,
+    KubernetesStepOperatorSettings,
+)
+from zenml.integrations.kubernetes.orchestrators import kube_utils
+from zenml.integrations.kubernetes.orchestrators.manifest_utils import (
+    build_pod_manifest,
+)
+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__)
+
+KUBERNETES_STEP_OPERATOR_DOCKER_IMAGE_KEY = "kubernetes_step_operator"
+
+
+class KubernetesStepOperator(BaseStepOperator):
+    """Step operator to run on Kubernetes."""
+
+    _k8s_client: Optional[k8s_client.ApiClient] = None
+
+    @property
+    def config(self) -> KubernetesStepOperatorConfig:
+        """Returns the `KubernetesStepOperatorConfig` config.
+
+        Returns:
+            The configuration.
+        """
+        return cast(KubernetesStepOperatorConfig, self._config)
+
+    @property
+    def settings_class(self) -> Optional[Type["BaseSettings"]]:
+        """Settings class for the Kubernetes step operator.
+
+        Returns:
+            The settings class.
+        """
+        return KubernetesStepOperatorSettings
+
+    @property
+    def validator(self) -> Optional[StackValidator]:
+        """Validates the stack.
+
+        Returns:
+            A validator that checks that the stack contains a remote container
+            registry and a remote artifact store.
+        """
+
+        def _validate_remote_components(stack: "Stack") -> Tuple[bool, str]:
+            if stack.artifact_store.config.is_local:
+                return False, (
+                    "The Kubernetes 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 Vertex "
+                    "step operator."
+                )
+
+            container_registry = stack.container_registry
+            assert container_registry is not None
+
+            if container_registry.config.is_local:
+                return False, (
+                    "The Kubernetes 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 "
+                    "Kubernetes 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"]:
+        """Gets the Docker builds required for the component.
+
+        Args:
+            deployment: The pipeline deployment for which to get the builds.
+
+        Returns:
+            The required Docker builds.
+        """
+        builds = []
+        for step_name, step in deployment.step_configurations.items():
+            if step.config.step_operator == self.name:
+                build = BuildConfiguration(
+                    key=KUBERNETES_STEP_OPERATOR_DOCKER_IMAGE_KEY,
+                    settings=step.config.docker_settings,
+                    step_name=step_name,
+                )
+                builds.append(build)
+
+        return builds
+
+    def get_kube_client(self) -> k8s_client.ApiClient:
+        """Get the Kubernetes API client.
+
+        Returns:
+            The Kubernetes API client.
+
+        Raises:
+            RuntimeError: If the service connector returns an unexpected client.
+        """
+        if self.config.incluster:
+            kube_utils.load_kube_config(incluster=True)
+            self._k8s_client = k8s_client.ApiClient()
+            return self._k8s_client
+
+        # Refresh the client also if the connector has expired
+        if self._k8s_client and not self.connector_has_expired():
+            return self._k8s_client
+
+        connector = self.get_connector()
+        if connector:
+            client = connector.connect()
+            if not isinstance(client, k8s_client.ApiClient):
+                raise RuntimeError(
+                    f"Expected a k8s_client.ApiClient while trying to use the "
+                    f"linked connector, but got {type(client)}."
+                )
+            self._k8s_client = client
+        else:
+            kube_utils.load_kube_config(
+                context=self.config.kubernetes_context,
+            )
+            self._k8s_client = k8s_client.ApiClient()
+
+        return self._k8s_client
+
+    @property
+    def _k8s_core_api(self) -> k8s_client.CoreV1Api:
+        """Getter for the Kubernetes Core API client.
+
+        Returns:
+            The Kubernetes Core API client.
+        """
+        return k8s_client.CoreV1Api(self.get_kube_client())
+
+    def launch(
+        self,
+        info: "StepRunInfo",
+        entrypoint_command: List[str],
+        environment: Dict[str, str],
+    ) -> None:
+        """Launches a step on Kubernetes.
+
+        Args:
+            info: Information about the step run.
+            entrypoint_command: Command that executes the step.
+            environment: Environment variables to set in the step operator
+                environment.
+        """
+        settings = cast(
+            KubernetesStepOperatorSettings, self.get_settings(info)
+        )
+        image_name = info.get_image(
+            key=KUBERNETES_STEP_OPERATOR_DOCKER_IMAGE_KEY
+        )
+
+        pod_name = f"{info.run_name}_{info.pipeline_step_name}"
+        pod_name = kube_utils.sanitize_pod_name(pod_name)
+
+        command = entrypoint_command[:3]
+        args = entrypoint_command[3:]
+
+        # Create and run the orchestrator pod.
+        pod_manifest = build_pod_manifest(
+            run_name=info.run_name,
+            pod_name=pod_name,
+            pipeline_name=info.pipeline.name,
+            image_name=image_name,
+            command=command,
+            args=args,
+            privileged=settings.privileged,
+            service_account_name=settings.service_account_name,
+            pod_settings=settings.pod_settings,
+            env=environment,
+            mount_local_stores=False,
+        )
+
+        self._k8s_core_api.create_namespaced_pod(
+            namespace=self.config.kubernetes_namespace,
+            body=pod_manifest,
+        )
+
+        logger.info(
+            "Waiting for pod of step `%s` to start...", info.pipeline_step_name
+        )
+        kube_utils.wait_pod(
+            kube_client_fn=self.get_kube_client,
+            pod_name=pod_name,
+            namespace=self.config.kubernetes_namespace,
+            exit_condition_lambda=kube_utils.pod_is_done,
+            stream_logs=True,
+        )
+        logger.info("Pod of step `%s` completed.", info.pipeline_step_name)

{zenml_nightly-0.62.0.dev20240726 → zenml_nightly-0.62.0.dev20240727}/src/zenml/models/v2/core/code_repository.py

@@ -18,7 +18,7 @@ from uuid import UUID
 
 from pydantic import Field
 
-from zenml.config.source import Source
+from zenml.config.source import Source, SourceWithValidator
 from zenml.constants import STR_FIELD_MAX_LENGTH, TEXT_FIELD_MAX_LENGTH
 from zenml.models.v2.base.base import BaseUpdate
 from zenml.models.v2.base.scoped import (
@@ -71,7 +71,7 @@ class CodeRepositoryUpdate(BaseUpdate):
         description="Configuration for the code repository.",
         default=None,
     )
-    source: Optional[Source] = Field(
+    source: Optional[SourceWithValidator] = Field(
         description="The code repository source.", default=None
     )
     logo_url: Optional[str] = Field(

zenml_nightly-0.62.0.dev20240726/src/zenml/VERSION

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