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

ROADMAP.md

@@ -1,5 +0,0 @@
-# Roadmap
-
-The roadmap is an encapsulation of the features that we intend to build for ZenML. However, please note that we limited resources and therefore no means of guaranteeing that this roadmap will be followed precisely as described on this page. Rest assured we are working to follow this diligently - please keep us in check!
-
-The roadmap is public and can be found [here](https://zenml.io/roadmap).

SECURITY.md

@@ -1,15 +0,0 @@
-# 🚨 Reporting a Vulnerability
-
-If you think you have found a vulnerability, and even if you are not sure about it,
-please report it right away by sending an
-email to: [support@zenml.com](mailto:support@zenml.com?subject=Security%20Vulnerability%20Found). Please try to be as explicit as possible,
-describing all the steps and example code to
-reproduce the security issue.
-
-We will review it thoroughly and get back to you.
-
-Please refrain from publicly discussing a potential security vulnerability as
-this could potentially put our users at
-risk! It's better to discuss privately and give us a chance to find a solution
-first, to limit the potential impact
-as much as possible.

zenml/_hub/client.py

@@ -1,285 +0,0 @@
-#  Copyright (c) ZenML GmbH 2023. 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.
-"""Client for the ZenML Hub."""
-import os
-from json import JSONDecodeError
-from typing import Any, Dict, List, Optional
-
-import requests
-
-from zenml._hub.constants import (
-    ZENML_HUB_ADMIN_USERNAME,
-    ZENML_HUB_CLIENT_TIMEOUT,
-    ZENML_HUB_CLIENT_VERIFY,
-    ZENML_HUB_DEFAULT_URL,
-)
-from zenml.analytics import source_context
-from zenml.client import Client
-from zenml.constants import ENV_ZENML_HUB_URL, IS_DEBUG_ENV
-from zenml.logger import get_logger
-from zenml.models import (
-    HubPluginRequestModel,
-    HubPluginResponseModel,
-    HubUserResponseModel,
-)
-
-logger = get_logger(__name__)
-
-
-class HubAPIError(Exception):
-    """Exception raised when the Hub returns an error or unexpected response."""
-
-
-class HubClient:
-    """Client for the ZenML Hub."""
-
-    def __init__(self, url: Optional[str] = None) -> None:
-        """Initialize the client.
-
-        Args:
-            url: The URL of the ZenML Hub.
-        """
-        self.url = url or self.get_default_url()
-        self.auth_token = Client().active_user.hub_token
-
-    @staticmethod
-    def get_default_url() -> str:
-        """Get the default URL of the ZenML Hub.
-
-        Returns:
-            The default URL of the ZenML Hub.
-        """
-        return os.getenv(ENV_ZENML_HUB_URL, default=ZENML_HUB_DEFAULT_URL)
-
-    def list_plugins(self, **params: Any) -> List[HubPluginResponseModel]:
-        """List all plugins in the hub.
-
-        Args:
-            **params: The query parameters to send in the request.
-
-        Returns:
-            The list of plugin response models.
-        """
-        response = self._request("GET", "/plugins", params=params)
-        if not isinstance(response, list):
-            return []
-        return [
-            HubPluginResponseModel.parse_obj(plugin) for plugin in response
-        ]
-
-    def get_plugin(
-        self,
-        name: str,
-        version: Optional[str] = None,
-        author: Optional[str] = None,
-    ) -> Optional[HubPluginResponseModel]:
-        """Get a specific plugin from the hub.
-
-        Args:
-            name: The name of the plugin.
-            version: The version of the plugin. If not specified, the latest
-                version will be returned.
-            author: Username of the author of the plugin.
-
-        Returns:
-            The plugin response model or None if the plugin does not exist.
-        """
-        route = "/plugins"
-        if not author:
-            author = ZENML_HUB_ADMIN_USERNAME
-        options = [
-            f"name={name}",
-            f"username={author}",
-        ]
-        if version:
-            options.append(f"version={version}")
-        if options:
-            route += "?" + "&".join(options)
-        try:
-            response = self._request("GET", route)
-        except HubAPIError:
-            return None
-        if not isinstance(response, list) or len(response) == 0:
-            return None
-        return HubPluginResponseModel.parse_obj(response[0])
-
-    def create_plugin(
-        self, plugin_request: HubPluginRequestModel
-    ) -> HubPluginResponseModel:
-        """Create a plugin in the hub.
-
-        Args:
-            plugin_request: The plugin request model.
-
-        Returns:
-            The plugin response model.
-        """
-        route = "/plugins"
-        response = self._request("POST", route, data=plugin_request.json())
-        return HubPluginResponseModel.parse_obj(response)
-
-    # TODO: Potentially reenable this later if hub adds logs streaming endpoint
-    # def stream_plugin_build_logs(
-    #     self, plugin_name: str, plugin_version: str
-    # ) -> bool:
-    #     """Stream the build logs of a plugin.
-
-    #     Args:
-    #         plugin_name: The name of the plugin.
-    #         plugin_version: The version of the plugin. If not specified, the
-    #             latest version will be used.
-
-    #     Returns:
-    #         Whether any logs were found.
-
-    #     Raises:
-    #         HubAPIError: If the build failed.
-    #     """
-    #     route = f"plugins/{plugin_name}/versions/{plugin_version}/logs"
-    #     logs_url = os.path.join(self.url, route)
-
-    #     found_logs = False
-    #     with requests.get(logs_url, stream=True) as response:
-    #         for line in response.iter_lines(
-    #             chunk_size=None, decode_unicode=True
-    #         ):
-    #             found_logs = True
-    #             if line.startswith("Build failed"):
-    #                 raise HubAPIError(line)
-    #             else:
-    #                 logger.info(line)
-    #     return found_logs
-
-    def login(self, username: str, password: str) -> None:
-        """Login to the ZenML Hub.
-
-        Args:
-            username: The username of the user in the ZenML Hub.
-            password: The password of the user in the ZenML Hub.
-
-        Raises:
-            HubAPIError: If the login failed.
-        """
-        route = "/auth/jwt/login"
-        response = self._request(
-            method="POST",
-            route=route,
-            data={"username": username, "password": password},
-            content_type="application/x-www-form-urlencoded",
-        )
-        if isinstance(response, dict):
-            auth_token = response.get("access_token")
-            if auth_token:
-                self.set_auth_token(str(auth_token))
-                return
-        raise HubAPIError(f"Unexpected response: {response}")
-
-    def set_auth_token(self, auth_token: Optional[str]) -> None:
-        """Set the auth token.
-
-        Args:
-            auth_token: The auth token to set.
-        """
-        client = Client()
-        client.update_user(
-            name_id_or_prefix=client.active_user.id,
-            updated_hub_token=auth_token,
-        )
-        self.auth_token = auth_token
-
-    def get_github_login_url(self) -> str:
-        """Get the GitHub login URL.
-
-        Returns:
-            The GitHub login URL.
-
-        Raises:
-            HubAPIError: If the request failed.
-        """
-        route = "/auth/github/authorize"
-        response = self._request("GET", route)
-        if isinstance(response, dict):
-            auth_url = response.get("authorization_url")
-            if auth_url:
-                return str(auth_url)
-        raise HubAPIError(f"Unexpected response: {str(response)}")
-
-    def get_me(self) -> Optional[HubUserResponseModel]:
-        """Get the current user.
-
-        Returns:
-            The user response model or None if the user does not exist.
-        """
-        try:
-            response = self._request("GET", "/users/me")
-            return HubUserResponseModel.parse_obj(response)
-        except HubAPIError:
-            return None
-
-    def _request(
-        self,
-        method: str,
-        route: str,
-        data: Optional[Any] = None,
-        params: Optional[Dict[str, Any]] = None,
-        content_type: str = "application/json",
-    ) -> Any:
-        """Helper function to make a request to the hub.
-
-        Args:
-            method: The HTTP method to use.
-            route: The route to send the request to, e.g., "/plugins".
-            data: The data to send in the request.
-            params: The query parameters to send in the request.
-            content_type: The content type of the request.
-
-        Returns:
-            The response JSON.
-
-        Raises:
-            HubAPIError: If the request failed.
-        """
-        session = requests.Session()
-
-        # Define headers
-        headers = {
-            "Accept": "application/json",
-            "Content-Type": content_type,
-            "Debug-Context": str(IS_DEBUG_ENV),
-            "Source-Context": str(source_context.get().value),
-        }
-        if self.auth_token:
-            headers["Authorization"] = f"Bearer {self.auth_token}"
-
-        # Make the request
-        route = route.lstrip("/")
-        endpoint_url = os.path.join(self.url, route)
-        response = session.request(
-            method=method,
-            url=endpoint_url,
-            data=data,
-            headers=headers,
-            params=params,
-            verify=ZENML_HUB_CLIENT_VERIFY,
-            timeout=ZENML_HUB_CLIENT_TIMEOUT,
-        )
-
-        # Parse and return the response
-        if 200 <= response.status_code < 300:
-            return response.json()
-        try:
-            error_msg = response.json().get("detail", response.text)
-        except JSONDecodeError:
-            error_msg = response.text
-        raise HubAPIError(f"Request to ZenML Hub failed: {error_msg}")

zenml/_hub/constants.py

@@ -1,21 +0,0 @@
-#  Copyright (c) ZenML GmbH 2023. 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.
-"""Constants for the ZenML hub."""
-
-ZENML_HUB_DEFAULT_URL = "https://hubapi.zenml.io/"
-ZENML_HUB_ADMIN_USERNAME = "ZenML"
-ZENML_HUB_CLIENT_VERIFY = True
-ZENML_HUB_CLIENT_TIMEOUT = 10
-ZENML_HUB_INTERNAL_TAG_PREFIX = "zenml-"
-ZENML_HUB_VERIFIED_TAG = "zenml-badge-verified"

zenml/_hub/utils.py

@@ -1,80 +0,0 @@
-#  Copyright (c) ZenML GmbH 2023. 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 functions for the ZenML Hub."""
-
-
-from typing import Optional, Tuple
-
-from zenml._hub.constants import ZENML_HUB_ADMIN_USERNAME
-
-
-def parse_plugin_name(
-    plugin_name: str, author_separator: str = "/", version_separator: str = ":"
-) -> Tuple[Optional[str], str, str]:
-    """Helper function to parse a plugin name.
-
-    Args:
-        plugin_name: The user-provided plugin name.
-        author_separator: The separator between the author username and the
-            plugin name.
-        version_separator: The separator between the plugin name and the
-            plugin version.
-
-    Returns:
-        - The author username or None if no author was specified.
-        - The plugin name.
-        - The plugin version or "latest" if no version was specified.
-
-    Raises:
-        ValueError: If the plugin name is invalid.
-    """
-    invalid_format_err_msg = (
-        f"Invalid plugin name '{plugin_name}'. Expected format: "
-        f"`(<author_username>{author_separator})<plugin_name>({version_separator}<version>)`."
-    )
-
-    parts = plugin_name.split(version_separator)
-    if len(parts) > 2:
-        raise ValueError(invalid_format_err_msg)
-    name, version = parts[0], "latest" if len(parts) == 1 else parts[1]
-
-    parts = name.split(author_separator)
-    if len(parts) > 2:
-        raise ValueError(invalid_format_err_msg)
-    name, author = parts[-1], None if len(parts) == 1 else parts[0]
-
-    if not name:
-        raise ValueError(invalid_format_err_msg)
-
-    return author, name, version
-
-
-def plugin_display_name(
-    name: str, version: Optional[str], author: Optional[str]
-) -> str:
-    """Helper function to get the display name of a plugin.
-
-    Args:
-        name: Name of the plugin.
-        version: Version of the plugin.
-        author: Username of the plugin author.
-
-    Returns:
-        Display name of the plugin.
-    """
-    author_prefix = ""
-    if author and author != ZENML_HUB_ADMIN_USERNAME:
-        author_prefix = f"{author}/"
-    version_suffix = f":{version}" if version else ":latest"
-    return f"{author_prefix}{name}{version_suffix}"

zenml/api.py

@@ -1,61 +0,0 @@
-#  Copyright (c) ZenML GmbH 2023. 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.
-"""Public Python API of ZenML.
-
-Everything defined/imported here should be highly import-optimized so we don't
-slow down the CLI.
-"""
-
-
-from typing import Optional
-
-from zenml.logger import get_logger
-
-logger = get_logger(__name__)
-
-
-def show(
-    ngrok_token: Optional[str] = None,
-    username: Optional[str] = None,
-    password: Optional[str] = None,
-) -> None:
-    """Show the ZenML dashboard.
-
-    Args:
-        ngrok_token: An ngrok auth token to use for exposing the ZenML
-            dashboard on a public domain. Primarily used for accessing the
-            dashboard in Colab.
-        username: The username to prefill in the login form.
-        password: The password to prefill in the login form.
-    """
-    from zenml.utils.dashboard_utils import show_dashboard
-    from zenml.utils.networking_utils import get_or_create_ngrok_tunnel
-    from zenml.zen_server.utils import get_active_server_details
-
-    url, port = get_active_server_details()
-
-    if ngrok_token and port:
-        ngrok_url = get_or_create_ngrok_tunnel(
-            ngrok_token=ngrok_token, port=port
-        )
-        logger.debug(f"Tunneling dashboard from {url} to {ngrok_url}.")
-        url = ngrok_url
-
-    url = f"{url}:{port}" if port else url
-    if username:
-        url += f"/login?username={username}"
-    if username and password:
-        url += f"&password={password}"
-
-    show_dashboard(url)