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

zenml/integrations/gcp/google_cloud_scheduler.py

@@ -1,83 +0,0 @@
-#  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.
-"""Utils for the Google Cloud Scheduler API."""
-
-import json
-import logging
-from typing import TYPE_CHECKING, Dict, Optional, Union
-
-from google.cloud import scheduler
-from google.cloud.scheduler_v1.types import (
-    CreateJobRequest,
-    HttpMethod,
-    HttpTarget,
-    Job,
-    OidcToken,
-)
-
-if TYPE_CHECKING:
-    from google.auth.credentials import Credentials
-
-
-def create_scheduler_job(
-    project: str,
-    region: str,
-    http_uri: str,
-    service_account_email: str,
-    body: Dict[str, Union[Dict[str, str], bool, str, None]],
-    credentials: Optional["Credentials"] = None,
-    schedule: str = "* * * * *",
-    time_zone: str = "Etc/UTC",
-) -> None:
-    """Creates a Google Cloud Scheduler job.
-
-    Job periodically sends POST request to the specified HTTP URI on a schedule.
-
-    Args:
-        project: GCP project ID.
-        region: GCP region.
-        http_uri: HTTP URI of the cloud function to call.
-        service_account_email: Service account email to use to authenticate to
-            the Google Cloud Function through an OIDC token.
-        body: The body of values to send to the cloud function in the POST call.
-        schedule: Cron expression of the schedule. Defaults to "* * * * *".
-        time_zone: Time zone of the schedule. Defaults to "Etc/UTC".
-        credentials: Credentials to use for GCP services.
-    """
-    # Create a client.
-    client = scheduler.CloudSchedulerClient(credentials=credentials)
-
-    # Construct the fully qualified location path.
-    parent = f"projects/{project}/locations/{region}"
-
-    # Use the client to send the job creation request.
-    job = client.create_job(
-        request=CreateJobRequest(
-            parent=parent,
-            job=Job(
-                http_target=HttpTarget(
-                    uri=http_uri,
-                    body=json.dumps(body).encode(),
-                    http_method=HttpMethod.POST,
-                    oidc_token=OidcToken(
-                        service_account_email=service_account_email
-                    ),
-                ),
-                schedule=schedule,
-                time_zone=time_zone,
-            ),
-        )
-    )
-
-    logging.debug(f"Created scheduler job. Response: {job}")

zenml/integrations/gcp/orchestrators/vertex_scheduler/main.py

@@ -1,91 +0,0 @@
-#  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.
-"""Entrypoint for the scheduled vertex job."""
-import json
-import logging
-import random
-from typing import TYPE_CHECKING
-
-from google.cloud import aiplatform
-
-if TYPE_CHECKING:
-    from flask import Request
-
-
-# Constants for the scheduler
-
-TEMPLATE_PATH = "template_path"
-JOB_ID = "job_id"
-PIPELINE_ROOT = "pipeline_root"
-PARAMETER_VALUES = "parameter_values"
-ENABLE_CACHING = "enable_caching"
-ENCRYPTION_SPEC_KEY_NAME = "encryption_spec_key_name"
-LABELS = "labels"
-PROJECT = "project"
-LOCATION = "location"
-WORKLOAD_SERVICE_ACCOUNT = "workload_service_account"
-NETWORK = "network"
-
-
-def trigger_vertex_job(request: "Request") -> str:
-    """Processes the incoming HTTP request.
-
-    Args:
-        request: HTTP request object.
-
-    Returns:
-        The response text or any set of values that can be turned into a Response.
-    """
-    # decode http request payload and translate into JSON object
-    request_str = request.data.decode("utf-8")
-    request_json = json.loads(request_str)
-
-    display_name = f"{request_json[JOB_ID]}-scheduled-{random.Random().getrandbits(32):08x}"
-
-    run = aiplatform.PipelineJob(
-        display_name=display_name,
-        template_path=request_json[TEMPLATE_PATH],
-        job_id=display_name,
-        pipeline_root=request_json[PIPELINE_ROOT],
-        parameter_values=request_json[PARAMETER_VALUES],
-        enable_caching=request_json[ENABLE_CACHING],
-        encryption_spec_key_name=request_json[ENCRYPTION_SPEC_KEY_NAME],
-        labels=request_json[LABELS],
-        project=request_json[PROJECT],
-        location=request_json[LOCATION],
-    )
-
-    workload_service_account = request_json[WORKLOAD_SERVICE_ACCOUNT]
-    network = request_json[NETWORK]
-
-    if workload_service_account:
-        logging.info(
-            "The Vertex AI Pipelines job workload will be executed "
-            "using the `%s` "
-            "service account.",
-            workload_service_account,
-        )
-
-    if network:
-        logging.info(
-            "The Vertex AI Pipelines job will be peered with the `%s` "
-            "network.",
-            network,
-        )
-
-    run.submit(
-        service_account=workload_service_account,
-        network=network,
-    )
-    return f"{display_name} submitted!"

zenml/integrations/gcp/orchestrators/vertex_scheduler/requirements.txt

@@ -1,2 +0,0 @@
-google-api-python-client>=1.7.8,<2
-google-cloud-aiplatform[pipelines]

zenml/integrations/kserve/__init__.py

@@ -1,57 +0,0 @@
-#  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.
-"""Initialization of the KServe integration for ZenML.
-
-The KServe integration allows you to use the KServe model serving
-platform to implement continuous model deployment.
-"""
-from typing import List, Type
-
-from zenml.enums import StackComponentType
-from zenml.integrations.constants import KSERVE
-from zenml.integrations.integration import Integration
-from zenml.stack import Flavor
-
-KSERVE_MODEL_DEPLOYER_FLAVOR = "kserve"
-
-
-class KServeIntegration(Integration):
-    """Definition of KServe integration for ZenML."""
-
-    NAME = KSERVE
-    REQUIREMENTS = [
-        "kserve>=0.9.0,<=10",
-        "torch-model-archiver",
-    ]
-
-    @classmethod
-    def activate(cls) -> None:
-        """Activate the KServe integration."""
-        from zenml.integrations.kserve import model_deployers  # noqa
-        from zenml.integrations.kserve import secret_schemas  # noqa
-        from zenml.integrations.kserve import services  # noqa
-
-    @classmethod
-    def flavors(cls) -> List[Type[Flavor]]:
-        """Declare the stack component flavors for KServe.
-
-        Returns:
-            List of stack component flavors for this integration.
-        """
-        from zenml.integrations.kserve.flavors import KServeModelDeployerFlavor
-
-        return [KServeModelDeployerFlavor]
-
-
-KServeIntegration.check_installation()

zenml/integrations/kserve/custom_deployer/zenml_custom_model.py

@@ -1,175 +0,0 @@
-#  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.
-"""Implements a custom model for the Kserve integration."""
-from typing import Any, Dict
-
-import click
-import kserve
-
-from zenml.logger import get_logger
-from zenml.utils import source_utils
-
-logger = get_logger(__name__)
-
-DEFAULT_MODEL_NAME = "model"
-DEFAULT_LOCAL_MODEL_DIR = "/mnt/models"
-
-
-class ZenMLCustomModel(kserve.Model):  # type: ignore[misc]
-    """Custom model class for ZenML and Kserve.
-
-    This class is used to implement a custom model for the Kserve integration,
-    which is used as the main entry point for custom code execution.
-
-    Attributes:
-        model_name: The name of the model.
-        model_uri: The URI of the model.
-        predict_func: The predict function of the model.
-    """
-
-    def __init__(
-        self,
-        model_name: str,
-        model_uri: str,
-        predict_func: str,
-    ):
-        """Initializes a ZenMLCustomModel object.
-
-        Args:
-            model_name: The name of the model.
-            model_uri: The URI of the model.
-            predict_func: The predict function of the model.
-        """
-        super().__init__(model_name)
-        self.name = model_name
-        self.model_uri = model_uri
-        self.predict_func = source_utils.load(predict_func)
-        self.model = None
-        self.ready = False
-
-    def load(self) -> bool:
-        """Load the model.
-
-        This function loads the model into memory and sets the ready flag to True.
-
-        The model is loaded using the materializer, by saving the information of
-        the artifact to a YAML file in the same path as the model artifacts at
-        the preparing time and loading it again at the prediction time by
-        the materializer.
-
-        Returns:
-            True if the model was loaded successfully, False otherwise.
-
-        """
-        try:
-            from zenml.artifacts.utils import load_model_from_metadata
-
-            self.model = load_model_from_metadata(self.model_uri)
-        except Exception as e:
-            logger.error("Failed to load model: {}".format(e))
-            return False
-        self.ready = True
-        return self.ready
-
-    def predict(self, request: Dict[str, Any]) -> Dict[str, Any]:
-        """Predict the given request.
-
-        The main predict function of the model. This function is called by the
-        KServe server when a request is received. Then inside this function,
-        the user-defined predict function is called.
-
-        Args:
-            request: The request to predict in a dictionary. e.g. {"instances": []}
-
-        Returns:
-            The prediction dictionary.
-
-        Raises:
-            RuntimeError: If function could not be called.
-            NotImplementedError: If the model is not ready.
-            TypeError: If the request is not a dictionary.
-        """
-        if self.predict_func is not None:
-            try:
-                prediction = {
-                    "predictions": self.predict_func(
-                        self.model, request["instances"]
-                    )
-                }
-            except RuntimeError as err:
-                raise RuntimeError("Failed to predict: {}".format(err))
-            if isinstance(prediction, dict):
-                return prediction
-            else:
-                raise TypeError(
-                    f"Prediction is not a dictionary. Expecting a dictionary but got {type(prediction)}"
-                )
-        else:
-            raise NotImplementedError("Predict function is not implemented")
-
-
-@click.command()
-@click.option(
-    "--model_uri",
-    default=DEFAULT_LOCAL_MODEL_DIR,
-    type=click.STRING,
-    help="The directory where the model is stored locally.",
-)
-@click.option(
-    "--model_name",
-    default=DEFAULT_MODEL_NAME,
-    required=True,
-    type=click.STRING,
-    help="The name of the model to deploy. This is important for the KServe server.",
-)
-@click.option(
-    "--predict_func",
-    required=True,
-    type=click.STRING,
-    help="The path to the custom predict function defined by the user.",
-)
-def main(model_name: str, model_uri: str, predict_func: str) -> None:
-    """Main function responsible for starting the KServe server.
-
-    The way the custom deployment server works with the KServe server is by
-    implementing a custom model class and passing it to the KServe server and then
-    starting the server. Because custom classes usually need some parameters to
-    be passed to the model, the parameters are passed from the entry point to the
-    main function as arguments and then passed to the model class constructor.
-
-    The following is an example of the entry point:
-    ```
-    entrypoint_command = [
-        "python",
-        "-m",
-        "zenml.integrations.kserve.custom_deployer.zenml_custom_model",
-        "--model_name",
-        config.service_config.model_name,
-        "--predict_func",
-        config.custom_deploy_parameters.predict_function,
-    ]
-    ```
-
-    Args:
-        model_name: The name of the model.
-        model_uri: The URI of the model.
-        predict_func: The path to the predict function defined by the user.
-    """
-    model = ZenMLCustomModel(model_name, model_uri, predict_func)
-    model.load()
-    kserve.ModelServer().start([model])
-
-
-if __name__ == "__main__":
-    main()

zenml/integrations/kserve/flavors/kserve_model_deployer_flavor.py

@@ -1,137 +0,0 @@
-#  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.
-"""KServe model deployer flavor."""
-
-from typing import TYPE_CHECKING, Optional, Type
-
-from zenml.constants import KUBERNETES_CLUSTER_RESOURCE_TYPE
-from zenml.integrations.kserve import KSERVE_MODEL_DEPLOYER_FLAVOR
-from zenml.model_deployers.base_model_deployer import (
-    BaseModelDeployerConfig,
-    BaseModelDeployerFlavor,
-)
-from zenml.models import ServiceConnectorRequirements
-
-if TYPE_CHECKING:
-    from zenml.integrations.kserve.model_deployers import KServeModelDeployer
-
-
-class KServeModelDeployerConfig(BaseModelDeployerConfig):
-    """Configuration for the KServeModelDeployer.
-
-    Attributes:
-        kubernetes_context: the Kubernetes context to use to contact the remote
-            KServe installation. If not specified, the current
-            configuration is used. Depending on where the KServe model deployer
-            is being used, this can be either a locally active context or an
-            in-cluster Kubernetes configuration (if running inside a pod).
-            If the model deployer stack component is linked to a Kubernetes
-            service connector, this field is ignored.
-        kubernetes_namespace: the Kubernetes namespace where the KServe
-            inference service CRDs are provisioned and managed by ZenML. If not
-            specified, the namespace set in the current configuration is used.
-            Depending on where the KServe model deployer is being used, this can
-            be either the current namespace configured in the locally active
-            context or the namespace in the context of which the pod is running
-            (if running inside a pod).
-        base_url: the base URL of the Kubernetes ingress used to expose the
-            KServe inference services.
-        secret: the name of the secret containing the credentials for the
-            KServe inference services.
-    """
-
-    kubernetes_context: Optional[str] = None
-    kubernetes_namespace: Optional[str] = None
-    base_url: str  # TODO: unused?
-    secret: Optional[str]
-    custom_domain: Optional[str]  # TODO: unused?
-
-
-class KServeModelDeployerFlavor(BaseModelDeployerFlavor):
-    """Flavor for the KServe model deployer."""
-
-    @property
-    def name(self) -> str:
-        """Name of the flavor.
-
-        Returns:
-            Name of the flavor.
-        """
-        return KSERVE_MODEL_DEPLOYER_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/model_deployer/kserve.png"
-
-    @property
-    def config_class(self) -> Type[KServeModelDeployerConfig]:
-        """Returns `KServeModelDeployerConfig` config class.
-
-        Returns:
-                The config class.
-        """
-        return KServeModelDeployerConfig
-
-    @property
-    def implementation_class(self) -> Type["KServeModelDeployer"]:
-        """Implementation class for this flavor.
-
-        Returns:
-            The implementation class.
-        """
-        from zenml.integrations.kserve.model_deployers import (
-            KServeModelDeployer,
-        )
-
-        return KServeModelDeployer