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

zenml/integrations/s3/utils.py

@@ -0,0 +1,39 @@
+#  Copyright (c) ZenML GmbH 2022. 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.
+"""Utility methods for S3."""
+
+from typing import Tuple
+
+
+def split_s3_path(s3_path: str) -> Tuple[str, str]:
+    """Split S3 URI into bucket and key.
+
+    Args:
+        s3_path: S3 URI (e.g. "s3://bucket/path")
+
+    Returns:
+        A tuple of bucket and key, for "s3://bucket/path/path2"
+            it will return ("bucket","path/path2")
+
+    Raises:
+        ValueError: if the S3 URI is invalid
+    """
+    if not s3_path.startswith("s3://"):
+        raise ValueError(
+            f"Invalid S3 URI given: {s3_path}. It should start with `s3://`."
+        )
+    path_parts = s3_path.replace("s3://", "").split("/")
+    bucket = path_parts.pop(0)
+    key = "/".join(path_parts)
+    return bucket, key

zenml/integrations/seldon/__init__.py

@@ -16,9 +16,8 @@
 The Seldon Core integration allows you to use the Seldon Core model serving
 platform to implement continuous model deployment.
 """
-from typing import List, Type
+from typing import List, Type, Optional
 
-from zenml.enums import StackComponentType
 from zenml.integrations.constants import SELDON
 from zenml.integrations.integration import Integration
 from zenml.stack import Flavor
@@ -34,6 +33,8 @@ class SeldonIntegration(Integration):
         "kubernetes==18.20.0",
     ]
 
+    REQUIREMENTS_IGNORED_ON_UNINSTALL = ["kubernetes", "numpy"]
+
     @classmethod
     def activate(cls) -> None:
         """Activate the Seldon Core integration."""
@@ -51,5 +52,20 @@ class SeldonIntegration(Integration):
 
         return [SeldonModelDeployerFlavor]
 
+    @classmethod
+    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+        """Method to get the requirements for the integration.
+
+        Args:
+            target_os: The target operating system to get the requirements for.
+
+        Returns:
+            A list of requirements.
+        """
+        from zenml.integrations.numpy import NumpyIntegration
+
+        return cls.REQUIREMENTS + \
+            NumpyIntegration.get_requirements(target_os=target_os)
+
 
 SeldonIntegration.check_installation()

zenml/integrations/seldon/model_deployers/seldon_model_deployer.py

@@ -15,7 +15,6 @@
 
 import json
 import re
-from datetime import datetime
 from typing import TYPE_CHECKING, ClassVar, Dict, List, Optional, Type, cast
 from uuid import UUID
 
@@ -291,6 +290,7 @@ class SeldonModelDeployer(BaseModelDeployer):
             assert isinstance(artifact_store, S3ArtifactStore)
 
             (
+                region_name,
                 aws_access_key_id,
                 aws_secret_access_key,
                 aws_session_token,
@@ -479,10 +479,10 @@ class SeldonModelDeployer(BaseModelDeployer):
                 return
         self.seldon_client.delete_secret(secret_name)
 
-    def deploy_model(
+    def perform_deploy_model(
         self,
+        id: UUID,
         config: ServiceConfig,
-        replace: bool = False,
         timeout: int = DEFAULT_SELDON_DEPLOYMENT_START_STOP_TIMEOUT,
     ) -> BaseService:
         """Create a new Seldon Core deployment or update an existing one.
@@ -517,11 +517,9 @@ class SeldonModelDeployer(BaseModelDeployer):
         to be updated and the others are deleted.
 
         Args:
+            id: the UUID of the model server to deploy.
             config: the configuration of the model to be deployed with Seldon.
                 Core
-            replace: set this flag to True to find and update an equivalent
-                Seldon Core deployment server with the new model instead of
-                starting a new deployment server.
             timeout: the timeout in seconds to wait for the Seldon Core server
                 to be provisioned and successfully started or updated. If set
                 to 0, the method will return immediately after the Seldon Core
@@ -541,31 +539,6 @@ class SeldonModelDeployer(BaseModelDeployer):
         """
         with track_handler(AnalyticsEvent.MODEL_DEPLOYED) as analytics_handler:
             config = cast(SeldonDeploymentConfig, config)
-            service = None
-
-            # if replace is True, find equivalent Seldon Core deployments
-            if replace is True:
-                equivalent_services = self.find_model_server(
-                    running=False,
-                    pipeline_name=config.pipeline_name,
-                    pipeline_step_name=config.pipeline_step_name,
-                    model_name=config.model_name,
-                )
-
-                for equivalent_service in equivalent_services:
-                    if service is None:
-                        # keep the most recently created service
-                        service = equivalent_service
-                    else:
-                        try:
-                            # delete the older services and don't wait for
-                            # them to be deprovisioned
-                            service.stop()
-                        except RuntimeError:
-                            # ignore errors encountered while stopping old
-                            # services
-                            pass
-
             # if a custom Kubernetes secret is not explicitly specified in the
             # SeldonDeploymentConfig, try to create one from the ZenML secret
             # configured for the model deployer
@@ -573,19 +546,9 @@ class SeldonModelDeployer(BaseModelDeployer):
                 config.secret_name
                 or self._create_or_update_kubernetes_secret()
             )
-
-            if service:
-                # update an equivalent service in place
-                service.update(config)
-                logger.info(
-                    f"Updating an existing Seldon deployment service: {service}"
-                )
-            else:
-                # create a new service
-                service = SeldonDeploymentService(config=config)
-                logger.info(
-                    f"Creating a new Seldon deployment service: {service}"
-                )
+            # create a new service
+            service = SeldonDeploymentService(uuid=id, config=config)
+            logger.info(f"Creating a new Seldon deployment service: {service}")
 
             # start the service which in turn provisions the Seldon Core
             # deployment server and waits for it to reach a ready state
@@ -606,95 +569,16 @@ class SeldonModelDeployer(BaseModelDeployer):
 
         return service
 
-    def find_model_server(
-        self,
-        running: bool = False,
-        service_uuid: Optional[UUID] = None,
-        pipeline_name: Optional[str] = None,
-        run_name: Optional[str] = None,
-        pipeline_step_name: Optional[str] = None,
-        model_name: Optional[str] = None,
-        model_uri: Optional[str] = None,
-        model_type: Optional[str] = None,
-    ) -> List[BaseService]:
-        """Find one or more Seldon Core model services that match the given criteria.
-
-        The Seldon Core deployment services that meet the search criteria are
-        returned sorted in descending order of their creation time (i.e. more
-        recent deployments first).
-
-        Args:
-            running: if true, only running services will be returned.
-            service_uuid: the UUID of the Seldon Core service that was
-                originally used to create the Seldon Core deployment resource.
-            pipeline_name: name of the pipeline that the deployed model was part
-                of.
-            run_name: Name of the pipeline run which the deployed model was
-                part of.
-            pipeline_step_name: the name of the pipeline model deployment step
-                that deployed the model.
-            model_name: the name of the deployed model.
-            model_uri: URI of the deployed model.
-            model_type: the Seldon Core server implementation used to serve
-                the model
-
-        Returns:
-            One or more Seldon Core service objects representing Seldon Core
-            model servers that match the input search criteria.
-        """
-        # Use a Seldon deployment service configuration to compute the labels
-        config = SeldonDeploymentConfig(
-            pipeline_name=pipeline_name or "",
-            run_name=run_name or "",
-            pipeline_run_id=run_name or "",
-            pipeline_step_name=pipeline_step_name or "",
-            model_name=model_name or "",
-            model_uri=model_uri or "",
-            implementation=model_type or "",
-        )
-        labels = config.get_seldon_deployment_labels()
-        if service_uuid:
-            # the service UUID is not a label covered by the Seldon
-            # deployment service configuration, so we need to add it
-            # separately
-            labels["zenml.service_uuid"] = str(service_uuid)
-
-        deployments = self.seldon_client.find_deployments(labels=labels)
-        # sort the deployments in descending order of their creation time
-        deployments.sort(
-            key=lambda deployment: datetime.strptime(
-                deployment.metadata.creationTimestamp,
-                "%Y-%m-%dT%H:%M:%SZ",
-            )
-            if deployment.metadata.creationTimestamp
-            else datetime.min,
-            reverse=True,
-        )
-
-        services: List[BaseService] = []
-        for deployment in deployments:
-            # recreate the Seldon deployment service object from the Seldon
-            # deployment resource
-            service = SeldonDeploymentService.create_from_deployment(
-                deployment=deployment
-            )
-            if running and not service.is_running:
-                # skip non-running services
-                continue
-            services.append(service)
-
-        return services
-
-    def stop_model_server(
+    def perform_stop_model(
         self,
-        uuid: UUID,
+        service: BaseService,
         timeout: int = DEFAULT_SELDON_DEPLOYMENT_START_STOP_TIMEOUT,
         force: bool = False,
-    ) -> None:
+    ) -> BaseService:
         """Stop a Seldon Core model server.
 
         Args:
-            uuid: UUID of the model server to stop.
+            service: The service to stop.
             timeout: timeout in seconds to wait for the service to stop.
             force: if True, force the service to stop.
 
@@ -707,15 +591,15 @@ class SeldonModelDeployer(BaseModelDeployer):
             "deleting the Seldon Core model server instead."
         )
 
-    def start_model_server(
+    def perform_start_model(
         self,
-        uuid: UUID,
+        service: BaseService,
         timeout: int = DEFAULT_SELDON_DEPLOYMENT_START_STOP_TIMEOUT,
-    ) -> None:
+    ) -> BaseService:
         """Start a Seldon Core model deployment server.
 
         Args:
-            uuid: UUID of the model server to start.
+            service: The service to start.
             timeout: timeout in seconds to wait for the service to become
                 active. . If set to 0, the method will return immediately after
                 provisioning the service, without waiting for it to become
@@ -729,28 +613,22 @@ class SeldonModelDeployer(BaseModelDeployer):
             "Starting Seldon Core model servers is not implemented"
         )
 
-    def delete_model_server(
+    def perform_delete_model(
         self,
-        uuid: UUID,
+        service: BaseService,
         timeout: int = DEFAULT_SELDON_DEPLOYMENT_START_STOP_TIMEOUT,
         force: bool = False,
     ) -> None:
         """Delete a Seldon Core model deployment server.
 
         Args:
-            uuid: UUID of the model server to delete.
+            service: The service to delete.
             timeout: timeout in seconds to wait for the service to stop. If
                 set to 0, the method will return immediately after
                 deprovisioning the service, without waiting for it to stop.
             force: if True, force the service to stop.
         """
-        services = self.find_model_server(service_uuid=uuid)
-        if len(services) == 0:
-            return
-
-        service = services[0]
-
-        assert isinstance(service, SeldonDeploymentService)
+        service = cast(SeldonDeploymentService, service)
         service.stop(timeout=timeout, force=force)
 
         if service.config.secret_name:

zenml/integrations/seldon/secret_schemas/secret_schemas.py

@@ -70,9 +70,9 @@ class SeldonGSSecretSchema(BaseSecretSchema):
         rclone_config_gs_auth_url: auth server URL.
     """
 
-    rclone_config_gs_type: Literal[
+    rclone_config_gs_type: Literal["google cloud storage"] = (
         "google cloud storage"
-    ] = "google cloud storage"
+    )
     rclone_config_gs_client_id: Optional[str] = None
     rclone_config_gs_client_secret: Optional[str] = None
     rclone_config_gs_project_number: Optional[str] = None

zenml/integrations/seldon/seldon_client.py

@@ -17,11 +17,11 @@ import base64
 import json
 import re
 import time
-from typing import Any, Dict, Generator, List, Optional
+from typing import Any, Dict, Generator, List, Literal, Optional
 
 from kubernetes import client as k8s_client
 from kubernetes import config as k8s_config
-from pydantic import BaseModel, Field, ValidationError
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
 
 from zenml.logger import get_logger
 from zenml.utils.enum_utils import StrEnum
@@ -30,9 +30,6 @@ logger = get_logger(__name__)
 
 api = k8s_client.ApiClient()
 
-SELDON_DEPLOYMENT_KIND = "SeldonDeployment"
-SELDON_DEPLOYMENT_API_VERSION = "machinelearning.seldon.io/v1"
-
 
 class SeldonDeploymentPredictorParameter(BaseModel):
     """Parameter for Seldon Deployment predictor.
@@ -46,14 +43,12 @@ class SeldonDeploymentPredictorParameter(BaseModel):
     name: str = ""
     type: str = ""
     value: str = ""
-
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonResourceRequirements(BaseModel):
@@ -82,14 +77,12 @@ class SeldonDeploymentMetadata(BaseModel):
     labels: Dict[str, str] = Field(default_factory=dict)
     annotations: Dict[str, str] = Field(default_factory=dict)
     creationTimestamp: Optional[str] = None
-
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonDeploymentPredictiveUnitType(StrEnum):
@@ -121,23 +114,21 @@ class SeldonDeploymentPredictiveUnit(BaseModel):
     """
 
     name: str
-    type: Optional[
-        SeldonDeploymentPredictiveUnitType
-    ] = SeldonDeploymentPredictiveUnitType.MODEL
+    type: Optional[SeldonDeploymentPredictiveUnitType] = (
+        SeldonDeploymentPredictiveUnitType.MODEL
+    )
     implementation: Optional[str] = None
     modelUri: Optional[str] = None
     parameters: Optional[List[SeldonDeploymentPredictorParameter]] = None
     serviceAccountName: Optional[str] = None
     envSecretRefName: Optional[str] = None
     children: Optional[List["SeldonDeploymentPredictiveUnit"]] = None
-
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonDeploymentComponentSpecs(BaseModel):
@@ -147,16 +138,13 @@ class SeldonDeploymentComponentSpecs(BaseModel):
         spec: the component spec.
     """
 
-    spec: Optional[Dict[str, Any]]
-    # TODO [HIGH]: Add graph field to ComponentSpecs. graph: Optional[SeldonDeploymentPredictiveUnit]
-
-    class Config:
-        """Pydantic configuration class."""
-
+    spec: Optional[Dict[str, Any]] = None
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonDeploymentPredictor(BaseModel):
@@ -175,14 +163,12 @@ class SeldonDeploymentPredictor(BaseModel):
         default_factory=SeldonResourceRequirements
     )
     componentSpecs: Optional[List[SeldonDeploymentComponentSpecs]] = None
-
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonDeploymentSpec(BaseModel):
@@ -196,17 +182,15 @@ class SeldonDeploymentSpec(BaseModel):
     """
 
     name: str
-    protocol: Optional[str]
+    protocol: Optional[str] = None
     predictors: List[SeldonDeploymentPredictor]
     replicas: int = 1
-
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonDeploymentStatusState(StrEnum):
@@ -242,8 +226,8 @@ class SeldonDeploymentStatusCondition(BaseModel):
 
     type: str
     status: bool
-    reason: Optional[str]
-    message: Optional[str]
+    reason: Optional[str] = None
+    message: Optional[str] = None
 
 
 class SeldonDeploymentStatus(BaseModel):
@@ -258,18 +242,16 @@ class SeldonDeploymentStatus(BaseModel):
     """
 
     state: SeldonDeploymentStatusState = SeldonDeploymentStatusState.UNKNOWN
-    description: Optional[str]
-    replicas: Optional[int]
-    address: Optional[SeldonDeploymentStatusAddress]
+    description: Optional[str] = None
+    replicas: Optional[int] = None
+    address: Optional[SeldonDeploymentStatusAddress] = None
     conditions: List[SeldonDeploymentStatusCondition]
-
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonDeployment(BaseModel):
@@ -292,8 +274,10 @@ class SeldonDeployment(BaseModel):
         status: Seldon Deployment status.
     """
 
-    kind: str = Field(SELDON_DEPLOYMENT_KIND, const=True)
-    apiVersion: str = Field(SELDON_DEPLOYMENT_API_VERSION, const=True)
+    kind: Literal["SeldonDeployment"] = "SeldonDeployment"
+    apiVersion: Literal["machinelearning.seldon.io/v1"] = (
+        "machinelearning.seldon.io/v1"
+    )
     metadata: SeldonDeploymentMetadata
     spec: SeldonDeploymentSpec
     status: Optional[SeldonDeploymentStatus] = None
@@ -304,7 +288,7 @@ class SeldonDeployment(BaseModel):
         Returns:
             A string representation of the Seldon Deployment.
         """
-        return json.dumps(self.dict(exclude_none=True), indent=4)
+        return json.dumps(self.model_dump(exclude_none=True), indent=4)
 
     @classmethod
     def build(
@@ -339,8 +323,10 @@ class SeldonDeployment(BaseModel):
             annotations: A dictionary of annotations to apply to the Seldon
                 Deployment.
             spec: A Kubernetes pod spec to use for the Seldon Deployment.
-            is_custom_deployment: Whether the Seldon Deployment is a custom or a built-in one.
-            serviceAccountName: The name of the service account to associate with the predictive unit container.
+            is_custom_deployment: Whether the Seldon Deployment is a custom
+                or a built-in one.
+            serviceAccountName: The name of the service account to associate
+                with the predictive unit container.
 
         Returns:
             A minimal SeldonDeployment object built from the provided
@@ -495,13 +481,12 @@ class SeldonDeployment(BaseModel):
             return None
         return ready_condition_message[0]
 
-    class Config:
-        """Pydantic configuration class."""
-
+    model_config = ConfigDict(
         # validate attribute assignments
-        validate_assignment = True
+        validate_assignment=True,
         # Ignore extra attributes from the CRD that are not reflected here
-        extra = "ignore"
+        extra="ignore",
+    )
 
 
 class SeldonClientError(Exception):
@@ -651,7 +636,7 @@ class SeldonClient:
             # are not
             deployment.mark_as_managed_by_zenml()
 
-            body_deploy = deployment.dict(exclude_none=True)
+            body_deploy = deployment.model_dump(exclude_none=True)
             response = (
                 self._custom_objects_api.create_namespaced_custom_object(
                     group="machinelearning.seldon.io",
@@ -788,7 +773,7 @@ class SeldonClient:
                 namespace=self._namespace,
                 plural="seldondeployments",
                 name=deployment.name,
-                body=deployment.dict(exclude_none=True),
+                body=deployment.model_dump(exclude_none=True),
                 _request_timeout=poll_timeout or None,
             )
             logger.debug("Seldon Core API response: %s", response)

zenml/integrations/seldon/services/seldon_deployment.py

@@ -86,8 +86,6 @@ class SeldonDeploymentConfig(ServiceConfig):
         labels = {}
         if self.pipeline_name:
             labels["zenml.pipeline_name"] = self.pipeline_name
-        if self.run_name:
-            labels["zenml.run_name"] = self.run_name
         if self.pipeline_step_name:
             labels["zenml.pipeline_step_name"] = self.pipeline_step_name
         if self.model_name:
@@ -115,7 +113,7 @@ class SeldonDeploymentConfig(ServiceConfig):
             The annotations for the Seldon Core deployment.
         """
         annotations = {
-            "zenml.service_config": self.json(),
+            "zenml.service_config": self.model_dump_json(),
             "zenml.version": __version__,
         }
         return annotations
@@ -135,7 +133,7 @@ class SeldonDeploymentConfig(ServiceConfig):
 
         Raises:
             ValueError: if the given deployment resource does not contain
-                the expected annotations or it contains an invalid or
+                the expected annotations, or it contains an invalid or
                 incompatible Seldon Core service configuration.
         """
         config_data = deployment.metadata.annotations.get(
@@ -147,7 +145,7 @@ class SeldonDeploymentConfig(ServiceConfig):
                 f"'zenml.service_config' annotation: {deployment}"
             )
         try:
-            service_config = cls.parse_raw(config_data)
+            service_config = cls.model_validate_json(config_data)
         except ValidationError as e:
             raise ValueError(
                 f"The loaded Seldon Core deployment resource contains an "
@@ -174,6 +172,7 @@ class SeldonDeploymentService(BaseDeploymentService):
         type="model-serving",
         flavor="seldon",
         description="Seldon Core prediction service",
+        logo_url="https://public-flavor-logos.s3.eu-central-1.amazonaws.com/model_deployer/seldon.png",
     )
 
     config: SeldonDeploymentConfig