zenml-nightly 0.84.2.dev20250826__py3-none-any.whl → 0.84.3.dev20250828__py3-none-any.whl

zenml/VERSION

@@ -1 +1 @@
-0.84.2.dev20250826
+0.84.3.dev20250828

zenml/cli/login.py

@@ -254,7 +254,7 @@ def connect_to_server(
             # flow.
             cli_utils.declare(f"Authenticating to ZenML server '{url}'...")
         else:
-            if refresh or not credentials_store.has_valid_authentication(url):
+            if refresh or not credentials_store.has_valid_credentials(url):
                 cli_utils.declare(
                     f"Authenticating to ZenML server '{url}' using the web "
                     "login..."
@@ -331,6 +331,17 @@ def connect_to_pro_server(
 
     server_id, server_url, server_name = None, None, None
     login = False
+    credentials_store = get_credentials_store()
+
+    if api_key and api_key.startswith("ZENPROKEY_"):
+        if not pro_server:
+            raise ValueError(
+                "You must provide the name of the ZenML Pro server when "
+                "connecting with a ZenML Pro API key."
+            )
+        credentials_store.set_api_key(pro_api_url, api_key, is_zenml_pro=True)
+        api_key = None
+
     if not pro_server:
         login = True
         if api_key:
@@ -351,8 +362,7 @@ def connect_to_pro_server(
     else:
         server_url = pro_server
 
-    credentials_store = get_credentials_store()
-    if not credentials_store.has_valid_pro_authentication(pro_api_url):
+    if not credentials_store.has_valid_pro_credentials(pro_api_url):
         # Without valid ZenML Pro credentials, we can only connect to a ZenML
         # Pro server with an API key and we also need to know the URL of the
         # server to connect to.
@@ -375,10 +385,9 @@ def connect_to_pro_server(
 
     if login or refresh:
         # If we reached this point, then we need to start a new login flow.
-        # We also need to remove all existing API tokens associated with the
-        # target ZenML Pro API, otherwise they will continue to be used after
-        # the re-login flow.
-        credentials_store.clear_all_pro_tokens()
+        # We also need to remove all existing credentials, otherwise they will
+        # continue to be used after the re-login flow.
+        credentials_store.clear_all_credentials()
         try:
             token = web_login(
                 pro_api_url=pro_api_url,
@@ -858,10 +867,21 @@ def login(
         )
         return
 
+    api_key_value: Optional[str] = None
+    if api_key:
+        # Read the API key from the user
+        api_key_value = click.prompt(
+            "Please enter the API key for the ZenML server",
+            type=str,
+            hide_input=True,
+        )
+        if api_key_value and api_key_value.startswith("ZENPROKEY_"):
+            pro = True
+
     if pro:
         connect_to_pro_server(
             pro_server=server,
-            refresh=True,
+            api_key=api_key_value,
             pro_api_url=pro_api_url,
             verify_ssl=ssl_ca_cert
             if ssl_ca_cert is not None
@@ -877,15 +897,6 @@ def login(
         if not connected_to_local_server():
             current_non_local_server = store_cfg.url
 
-    api_key_value: Optional[str] = None
-    if api_key:
-        # Read the API key from the user
-        api_key_value = click.prompt(
-            "Please enter the API key for the ZenML server",
-            type=str,
-            hide_input=True,
-        )
-
     verify_ssl: Union[str, bool] = (
         ssl_ca_cert if ssl_ca_cert is not None else not no_verify_ssl
     )
@@ -1126,7 +1137,7 @@ def logout(
 
         pro_api_url = pro_api_url or ZENML_PRO_API_URL
         pro_api_url = pro_api_url.rstrip("/")
-        if credentials_store.has_valid_pro_authentication(pro_api_url):
+        if credentials_store.get_pro_credentials(pro_api_url):
             credentials_store.clear_pro_credentials(pro_api_url)
             cli_utils.declare("Logged out from ZenML Pro.")
         else:
@@ -1141,7 +1152,7 @@ def logout(
             if credentials and credentials.pro_api_url == pro_api_url:
                 gc.set_default_store()
 
-            credentials_store.clear_all_pro_tokens(pro_api_url)
+            credentials_store.clear_all_credentials()
             cli_utils.declare("Logged out from all ZenML Pro servers.")
         return
 

zenml/cli/server.py

@@ -217,12 +217,12 @@ def status() -> None:
         if server:
             if server.type == ServerType.PRO:
                 # If connected to a ZenML Pro server, refresh the server info
-                pro_credentials = credentials_store.get_pro_credentials(
-                    pro_api_url=server.pro_api_url or ZENML_PRO_API_URL,
-                    allow_expired=False,
-                )
-                if pro_credentials:
-                    pro_client = ZenMLProClient(pro_credentials.url)
+                if credentials_store.can_login(
+                    server_url=server.pro_api_url or ZENML_PRO_API_URL,
+                ):
+                    pro_client = ZenMLProClient(
+                        server.pro_api_url or ZENML_PRO_API_URL
+                    )
                     pro_servers = pro_client.workspace.list(
                         url=store_cfg.url, member_only=True
                     )
@@ -240,10 +240,6 @@ def status() -> None:
                 cli_utils.declare(
                     f"  ZenML Pro Organization: {server.organization_hyperlink}"
                 )
-                if pro_credentials:
-                    cli_utils.declare(
-                        f"  ZenML Pro authentication: {pro_credentials.auth_status}"
-                    )
             else:
                 cli_utils.declare(
                     f"Connected to a remote ZenML server: `{server.dashboard_hyperlink}`"

zenml/login/credentials.py

@@ -138,6 +138,33 @@ class ServerCredentials(BaseModel):
             return ServerType.LOCAL
         return ServerType.REMOTE
 
+    @property
+    def can_refresh_token(self) -> bool:
+        """Check if the credentials can be used to refresh the API token.
+
+        A token refresh is only possible if long-lived credentials exist that
+        can be used to login and generate a new API token.
+
+        Returns:
+            True if the server credentials can be used to refresh the API token,
+            False otherwise.
+        """
+        return (
+            self.username is not None
+            and self.password is not None
+            or self.api_key is not None
+            or self.type == ServerType.LOCAL
+        )
+
+    @property
+    def has_valid_token(self) -> bool:
+        """Check if the API token is valid.
+
+        Returns:
+            True if the API token is valid, False otherwise.
+        """
+        return self.api_token is not None and not self.api_token.expired
+
     def update_server_info(
         self, server_info: Union[ServerModel, WorkspaceRead]
     ) -> None:

zenml/login/credentials_store.py

@@ -54,12 +54,15 @@ class CredentialsStore(metaclass=SingletonMetaClass):
         1. when the user runs `zenml login` to authenticate to a ZenML Pro
         server, the ZenML Pro API token fetched from the web login flow is
         stored in the Credentials Store.
-        2. when the user runs `zenml login` to authenticate to a regular ZenML
+        2. when the user runs `zenml login` to authenticate to a ZenML Pro
+        server using an API key, the ZenML Pro API key is stored in the
+        Credentials Store.
+        3. when the user runs `zenml login` to authenticate to a regular ZenML
         server with the web login flow, the ZenML server API token fetched
         through the web login flow is stored in the Credentials Store
-        3. when the user runs `zenml login` to authenticate to any ZenML server
+        4. when the user runs `zenml login` to authenticate to any ZenML server
         using an API key, the API key is stored in the Credentials Store
-        4. when the REST zen store is initialized, it starts up not yet
+        5. when the REST zen store is initialized, it starts up not yet
         authenticated. Then, if/when it needs to authenticate or re-authenticate
         to the remote server, it will use whatever form of credentials it finds
         in the Credentials Store, in order of priority:
@@ -71,8 +74,12 @@ class CredentialsStore(metaclass=SingletonMetaClass):
             * for ZenML servers that use an API key to authenticate, it will use
             that to fetch a short-lived ZenML Pro server API token that it also
             stores in the Credentials Store
-            * for ZenML Pro servers, it exchanges the longer-lived ZenML Pro API
-            token into a short lived ZenML Pro server API token
+            * for ZenML Pro servers:
+                * if a valid ZenML Pro API token is found, it exchanges it into
+                a short lived ZenML Pro server API token
+                * otherwise, if a ZenML Pro API key is found, it will use that
+                to fetch a short-lived ZenML Pro server API token that it also
+                stores in the Credentials Store
 
     Alongside credentials, the Credentials Store is also used to store
     additional server information:
@@ -290,6 +297,37 @@ class CredentialsStore(metaclass=SingletonMetaClass):
         self.check_and_reload_from_file()
         return self.credentials.get(server_url)
 
+    def has_valid_credentials(self, server_url: str) -> bool:
+        """Check if valid credentials exist for a specific server URL.
+
+        Args:
+            server_url: The server URL for which to check the authentication.
+
+        Returns:
+            True if the credentials store contains credentials that can be used
+            to login to the given server URL, False otherwise.
+        """
+        credentials = self.get_credentials(server_url)
+        if credentials and (
+            credentials.has_valid_token or credentials.can_refresh_token
+        ):
+            return True
+        return False
+
+    def get_pro_api_key(self, pro_api_url: str) -> Optional[str]:
+        """Retrieve an API key from the credentials store for a ZenML Pro API server.
+
+        Args:
+            pro_api_url: The URL of the ZenML Pro API server.
+
+        Returns:
+            The stored API key if it exists, None otherwise.
+        """
+        credential = self.get_pro_credentials(pro_api_url)
+        if credential and credential.api_key:
+            return credential.api_key
+        return None
+
     def get_pro_token(
         self, pro_api_url: str, allow_expired: bool = False
     ) -> Optional[APIToken]:
@@ -304,98 +342,58 @@ class CredentialsStore(metaclass=SingletonMetaClass):
         Returns:
             The stored token if it exists and is not expired, None otherwise.
         """
-        credential = self.get_pro_credentials(pro_api_url, allow_expired)
+        credential = self.get_pro_credentials(pro_api_url)
         if credential:
-            return credential.api_token
+            token = credential.api_token
+            if token and (not token.expired or allow_expired):
+                return token
         return None
 
     def get_pro_credentials(
-        self, pro_api_url: str, allow_expired: bool = False
+        self, pro_api_url: str
     ) -> Optional[ServerCredentials]:
-        """Retrieve a valid token from the credentials store for a ZenML Pro API server.
+        """Retrieve valid credentials from the credentials store for a ZenML Pro API server.
 
         Args:
             pro_api_url: The URL of the ZenML Pro API server.
-            allow_expired: Whether to allow expired tokens to be returned. The
-                default behavior is to return None if a token does exist but is
-                expired.
 
         Returns:
-            The stored credentials if they exist and are not expired, None otherwise.
+            The stored credentials if they exist, None otherwise.
         """
         credential = self.get_credentials(pro_api_url)
-        if (
-            credential
-            and credential.type == ServerType.PRO_API
-            and credential.api_token
-            and (not credential.api_token.expired or allow_expired)
-        ):
+        if credential and credential.type == ServerType.PRO_API:
             return credential
         return None
 
-    def clear_pro_credentials(self, pro_api_url: str) -> None:
-        """Delete the token from the store for a ZenML Pro API server.
-
-        Args:
-            pro_api_url: The URL of the ZenML Pro API server.
-        """
-        self.clear_token(pro_api_url)
-
-    def clear_all_pro_tokens(
-        self, pro_api_url: Optional[str] = None
-    ) -> List[ServerCredentials]:
-        """Delete all tokens from the store for ZenML Pro servers connected to a given API server.
+    def has_valid_pro_credentials(self, pro_api_url: str) -> bool:
+        """Check if valid credentials exist for a ZenML Pro API server.
 
         Args:
             pro_api_url: The URL of the ZenML Pro API server.
 
         Returns:
-            A list of the credentials that were cleared.
-        """
-        credentials_to_clear = []
-        for server_url, server in self.credentials.copy().items():
-            if (
-                server.type == ServerType.PRO
-                and server.pro_api_url
-                and (pro_api_url is None or server.pro_api_url == pro_api_url)
-            ):
-                if server.api_key:
-                    continue
-                self.clear_token(server_url)
-                credentials_to_clear.append(server)
-        return credentials_to_clear
-
-    def has_valid_authentication(self, url: str) -> bool:
-        """Check if a valid authentication credential for the given server URL is stored.
-
-        Args:
-            url: The server URL for which to check the authentication.
-
-        Returns:
-            bool: True if a valid token or API key is stored, False otherwise.
+            True if the credentials store contains credentials that can be used
+            to login to the given ZenML Pro API server, False otherwise.
         """
-        self.check_and_reload_from_file()
-        credential = self.credentials.get(url)
-
-        if not credential:
-            return False
-        if credential.api_key or (
-            credential.username and credential.password is not None
+        credentials = self.get_pro_credentials(pro_api_url)
+        if credentials and (
+            credentials.has_valid_token or credentials.can_refresh_token
         ):
             return True
-        token = credential.api_token
-        return token is not None and not token.expired
+        return False
 
-    def has_valid_pro_authentication(self, pro_api_url: str) -> bool:
-        """Check if a valid token for a ZenML Pro API server is stored.
+    def clear_pro_credentials(self, pro_api_url: str) -> None:
+        """Delete the token from the store for a ZenML Pro API server.
 
         Args:
             pro_api_url: The URL of the ZenML Pro API server.
-
-        Returns:
-            bool: True if a valid token is stored, False otherwise.
         """
-        return self.get_pro_token(pro_api_url) is not None
+        self.clear_token(pro_api_url)
+
+    def clear_all_credentials(self) -> None:
+        """Delete all stored credentials."""
+        self.credentials = {}
+        self._save_credentials()
 
     def can_login(self, server_url: str) -> bool:
         """Check if credentials to login to the given server exist.
@@ -407,22 +405,20 @@ class CredentialsStore(metaclass=SingletonMetaClass):
             True if the credentials store contains credentials that can be used
             to login to the given server URL, False otherwise.
         """
-        self.check_and_reload_from_file()
         credentials = self.get_credentials(server_url)
         if not credentials:
             return False
 
-        if credentials.api_key is not None:
-            return True
-        elif (
-            credentials.username is not None
-            and credentials.password is not None
-        ):
+        if credentials.can_refresh_token:
             return True
-        elif credentials.type == ServerType.PRO:
+
+        if credentials.type == ServerType.PRO:
             pro_api_url = credentials.pro_api_url or ZENML_PRO_API_URL
-            pro_token = self.get_pro_token(pro_api_url, allow_expired=False)
-            if pro_token:
+            pro_credentials = self.get_pro_credentials(pro_api_url)
+            if pro_credentials and (
+                pro_credentials.has_valid_token
+                or pro_credentials.can_refresh_token
+            ):
                 return True
 
         return False
@@ -431,6 +427,7 @@ class CredentialsStore(metaclass=SingletonMetaClass):
         self,
         server_url: str,
         api_key: str,
+        is_zenml_pro: bool = False,
     ) -> None:
         """Store an API key in the credentials store for a specific server URL.
 
@@ -440,6 +437,7 @@ class CredentialsStore(metaclass=SingletonMetaClass):
         Args:
             server_url: The server URL for which the token is to be stored.
             api_key: The API key to store.
+            is_zenml_pro: Whether the API key is for the ZenML Pro API.
         """
         self.check_and_reload_from_file()
         credential = self.credentials.get(server_url)
@@ -450,9 +448,11 @@ class CredentialsStore(metaclass=SingletonMetaClass):
             credential.api_key = api_key
             credential.username = None
             credential.password = None
+            if is_zenml_pro:
+                credential.pro_api_url = server_url
         else:
             self.credentials[server_url] = ServerCredentials(
-                url=server_url, api_key=api_key
+                url=server_url, api_key=api_key, pro_api_url=server_url
             )
 
         self._save_credentials()

zenml/login/pro/client.py

@@ -34,6 +34,7 @@ from zenml.logger import get_logger
 from zenml.login.credentials import APIToken
 from zenml.login.credentials_store import get_credentials_store
 from zenml.login.pro.models import BaseRestAPIModel
+from zenml.models.v2.misc.auth_models import OAuthTokenResponse
 from zenml.utils.singleton import SingletonMetaClass
 from zenml.zen_server.exceptions import exception_from_response
 
@@ -54,39 +55,54 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
     """ZenML Pro client."""
 
     _url: str
-    _api_token: APIToken
+    _api_token: Optional[APIToken] = None
     _session: Optional[requests.Session] = None
     _workspace: Optional["WorkspaceClient"] = None
     _organization: Optional["OrganizationClient"] = None
 
-    def __init__(self, url: str, api_token: Optional[APIToken] = None) -> None:
+    def __init__(self, url: str) -> None:
         """Initialize the ZenML Pro client.
 
         Args:
             url: The URL of the ZenML Pro API server.
-            api_token: The API token to use for authentication. If not provided,
-                the token is fetched from the credentials store.
+        """
+        self._url = url
+
+    def authenticate(self) -> APIToken:
+        """Authenticate to ZenML Pro and return the API token.
+
+        Returns:
+            The API token.
 
         Raises:
-            AuthorizationException: If no API token is provided and no token
-                is found in the credentials store.
+            AuthorizationException: If the login fails.
         """
-        self._url = url
-        if api_token is None:
-            logger.debug(
-                "No ZenML Pro API token provided. Fetching from credentials "
-                "store."
+        credentials_store = get_credentials_store()
+        pro_credentials = credentials_store.get_pro_credentials(self._url)
+        if pro_credentials is None:
+            raise AuthorizationException(
+                "No ZenML Pro credentials found. Please run 'zenml login' to "
+                "login to ZenML Pro."
             )
-            api_token = get_credentials_store().get_token(
-                server_url=self._url, allow_expired=True
+        if pro_credentials.has_valid_token:
+            assert pro_credentials.api_token is not None
+            return pro_credentials.api_token
+
+        if pro_credentials.can_refresh_token:
+            assert pro_credentials.api_key is not None
+            api_token = self.fetch_api_token(
+                self._url, pro_credentials.api_key
+            )
+            return credentials_store.set_token(
+                self._url,
+                api_token,
+                is_zenml_pro=True,
+            )
+        else:
+            raise AuthorizationException(
+                "Your ZenML Pro authentication has expired. Please run "
+                "'zenml login' to login again."
             )
-            if api_token is None:
-                raise AuthorizationException(
-                    "No ZenML Pro API token found. Please run 'zenml login' to "
-                    "login to ZenML Pro."
-                )
-
-        self._api_token = api_token
 
     @property
     def workspace(self) -> "WorkspaceClient":
@@ -121,20 +137,10 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
         Returns:
             The API token.
         """
+        if self._api_token is None or self._api_token.expired:
+            self._api_token = self.authenticate()
         return self._api_token.access_token
 
-    def raise_on_expired_api_token(self) -> None:
-        """Raise an exception if the API token has expired.
-
-        Raises:
-            AuthorizationException: If the API token has expired.
-        """
-        if self._api_token and self._api_token.expired:
-            raise AuthorizationException(
-                "Your ZenML Pro authentication has expired. Please run "
-                "'zenml login' to login again."
-            )
-
     @property
     def session(self) -> requests.Session:
         """Authenticate to the ZenML Pro API server.
@@ -142,10 +148,6 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
         Returns:
             A requests session with the authentication token.
         """
-        # Check if the API token has expired before every call to the server.
-        # This prevents unwanted authorization errors from being raised during
-        # the call itself.
-        self.raise_on_expired_api_token()
         if self._session is None:
             self._session = requests.Session()
             retries = Retry(backoff_factor=0.1, connect=5)
@@ -157,6 +159,35 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
             logger.debug("Authenticated to ZenML Pro server.")
         return self._session
 
+    @classmethod
+    def fetch_api_token(cls, url: str, api_key: str) -> OAuthTokenResponse:
+        """Fetch the API token for a given ZenML Pro server URL.
+
+        Args:
+            url: ZenML Pro server URL
+            api_key: API key
+
+        Returns:
+            The API token.
+
+        Raises:
+            ValueError: if the response is not in the right format.
+        """
+        headers = {"Authorization": "Bearer " + api_key}
+        response = requests.post(
+            url + "/auth/login",
+            data={"password": api_key},
+            headers=headers,
+            timeout=10,
+        )
+        json_response = cls._handle_response(response)
+        if not isinstance(json_response, dict):
+            raise ValueError(
+                f"Bad response from API. Expected dict, got\n{json_response}"
+            )
+
+        return OAuthTokenResponse.model_validate(json_response)
+
     @staticmethod
     def _handle_response(response: requests.Response) -> Json:
         """Handle API response, translating http status codes to Exception.
@@ -215,10 +246,6 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
 
         Returns:
             The parsed response.
-
-        Raises:
-            AuthorizationException: if the request fails due to an expired
-                authentication token.
         """
         params = {k: str(v) for k, v in params.items()} if params else {}
 
@@ -226,21 +253,14 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
             {source_context.name: source_context.get().value}
         )
 
-        try:
-            return self._handle_response(
-                self.session.request(
-                    method,
-                    url,
-                    params=params,
-                    **kwargs,
-                )
+        return self._handle_response(
+            self.session.request(
+                method,
+                url,
+                params=params,
+                **kwargs,
             )
-        except AuthorizationException:
-            # Check if this is caused by an expired API token.
-            self.raise_on_expired_api_token()
-
-            # If not, raise the exception.
-            raise
+        )
 
     def get(
         self,

zenml/login/pro/utils.py

@@ -39,9 +39,7 @@ def get_troubleshooting_instructions(url: str) -> str:
     if credentials and credentials.type == ServerType.PRO:
         pro_api_url = credentials.pro_api_url or ZENML_PRO_API_URL
 
-    if pro_api_url and credentials_store.has_valid_pro_authentication(
-        pro_api_url
-    ):
+    if pro_api_url and credentials_store.can_login(pro_api_url):
         client = ZenMLProClient(pro_api_url)
 
         try:

zenml/utils/package_utils.py

@@ -42,7 +42,7 @@ def is_latest_zenml_version() -> bool:
         True in case the current running zenml code is the latest available version on PYPI, otherwise False.
 
     Raises:
-        RuntimeError: In case something goe wrong
+        RuntimeError: In case something goes wrong
     """
     from zenml import __version__
 

zenml/zen_server/dashboard/assets/{404-CMbwR10f.js → 404-JcbBcNWG.js}

@@ -1 +1 @@
-import{j as e}from"./@radix-B1sy0Lhr.js";import{B as s,r as t}from"./index-CO6UN3UX.js";import{E as r}from"./EmptyState-BMA34iVR.js";import{S as a}from"./help-CRPfbPTO.js";import{L as o}from"./@react-router-CHjLNlgw.js";import"./@tanstack-Dwlisomv.js";import"./@reactflow-gbyyU3kq.js";function d(){return e.jsx("div",{className:"flex min-h-screen w-full flex-col",children:e.jsx(r,{icon:e.jsx(a,{className:"h-[120px] w-[120px] fill-neutral-300"}),children:e.jsxs("div",{className:"text-center",children:[e.jsx("h1",{className:"mb-2 text-display-xs font-semibold",children:"We can't find the page you are looking for"}),e.jsx("p",{className:"text-lg text-theme-text-secondary",children:"You can try typing a different URL or we can bring you back to your Homepage."}),e.jsx("div",{className:"mt-5 flex justify-center",children:e.jsx(s,{size:"md",asChild:!0,children:e.jsx(o,{className:"w-min self-center whitespace-nowrap",to:t.projects.overview,children:e.jsx("span",{className:"px-0.5",children:"Go to Home"})})})})]})})})}export{d as default};
+import{j as e}from"./@radix-B1sy0Lhr.js";import{B as s,r as t}from"./index-Ci5z7q6x.js";import{E as r}from"./EmptyState-BMA34iVR.js";import{S as a}from"./help-CRPfbPTO.js";import{L as o}from"./@react-router-CHjLNlgw.js";import"./@tanstack-Dwlisomv.js";import"./@reactflow-gbyyU3kq.js";function d(){return e.jsx("div",{className:"flex min-h-screen w-full flex-col",children:e.jsx(r,{icon:e.jsx(a,{className:"h-[120px] w-[120px] fill-neutral-300"}),children:e.jsxs("div",{className:"text-center",children:[e.jsx("h1",{className:"mb-2 text-display-xs font-semibold",children:"We can't find the page you are looking for"}),e.jsx("p",{className:"text-lg text-theme-text-secondary",children:"You can try typing a different URL or we can bring you back to your Homepage."}),e.jsx("div",{className:"mt-5 flex justify-center",children:e.jsx(s,{size:"md",asChild:!0,children:e.jsx(o,{className:"w-min self-center whitespace-nowrap",to:t.projects.overview,children:e.jsx("span",{className:"px-0.5",children:"Go to Home"})})})})]})})})}export{d as default};

zenml/zen_server/dashboard/assets/{AlertDialogDropdownItem-BpLj419i.js → AlertDialogDropdownItem-DuTp8JFP.js}

@@ -1 +1 @@
-import{r as m,j as e}from"./@radix-B1sy0Lhr.js";import{J as g,K as p,aw as d,br as h}from"./index-CO6UN3UX.js";const x=m.forwardRef((r,t)=>{const{triggerChildren:a,children:i,onSelect:o,onOpenChange:l,icon:D,open:n,...s}=r;return e.jsxs(g,{open:n,onOpenChange:l,children:[e.jsx(p,{asChild:!0,children:e.jsx(d,{...s,className:"hover:cursor-pointer",icon:r.icon,ref:t,onSelect:c=>{c.preventDefault(),o&&o()},children:a})}),e.jsx(h,{children:i})]})});x.displayName="AlertDialogItem";export{x as A};
+import{r as m,j as e}from"./@radix-B1sy0Lhr.js";import{J as g,K as p,aw as d,br as h}from"./index-Ci5z7q6x.js";const x=m.forwardRef((r,t)=>{const{triggerChildren:a,children:i,onSelect:o,onOpenChange:l,icon:D,open:n,...s}=r;return e.jsxs(g,{open:n,onOpenChange:l,children:[e.jsx(p,{asChild:!0,children:e.jsx(d,{...s,className:"hover:cursor-pointer",icon:r.icon,ref:t,onSelect:c=>{c.preventDefault(),o&&o()},children:a})}),e.jsx(h,{children:i})]})});x.displayName="AlertDialogItem";export{x as A};

zenml/zen_server/dashboard/assets/{ButtonGroup-DVhzbQxV.js → ButtonGroup-B9_gfcC-.js}

@@ -1 +1 @@
-import{r as l,j as e}from"./@radix-B1sy0Lhr.js";import{L as j,M as R,N as w,O as C,J as b,K as y,B as O}from"./index-CO6UN3UX.js";import{S as h}from"./trash-D9LA4VFD.js";import{A as v}from"./AlertDialogDropdownItem-BpLj419i.js";import{D as f,a as p}from"./DeleteAlertDialog-CzhTVQaC.js";import{c as A,u as S}from"./bulk-delete-wdObjfps.js";import{u as T}from"./delete-run-XSre8ru-.js";const{ContextProvider:F,useContext:c}=A();function m(){const{setRowSelection:n}=c(),{mutateAsync:t}=T();async function s(r){await t({runId:r})}return S({deleteFn:s,queryKeyToInvalidate:["runs"],setRowSelection:n})}function H({id:n}){const[t,s]=l.useState(!1),[r,a]=l.useState(!1),i=l.useRef(null),u=l.useRef(null),{bulkDelete:x}=m();async function D(){await x([n]),d(!1)}function g(){u.current=i.current}function d(o){if(o===!1){a(!1),setTimeout(()=>{s(o)},200);return}s(o)}return e.jsxs(j,{onOpenChange:a,open:r,children:[e.jsx(R,{ref:i,children:e.jsx(w,{className:"h-4 w-4 fill-theme-text-tertiary"})}),e.jsx(C,{hidden:t,onCloseAutoFocus:o=>{u.current&&(u.current.focus(),u.current=null,o.preventDefault())},align:"end",sideOffset:7,children:e.jsx(v,{onSelect:g,open:t,onOpenChange:d,triggerChildren:"Delete",icon:e.jsx(h,{fill:"red"}),children:e.jsx(f,{title:"Delete Run",handleDelete:D,children:e.jsxs(p,{children:[e.jsx("p",{children:"Are you sure?"}),e.jsx("p",{children:"This action cannot be undone."})]})})})})]})}function I(){const[n,t]=l.useState(!1),{selectedRowCount:s,selectedRowIDs:r}=c(),{bulkDelete:a}=m();async function i(){await a(r),t(!1)}return e.jsxs(b,{open:n,onOpenChange:t,children:[e.jsx(y,{asChild:!0,children:e.jsxs(O,{className:"rounded-sharp border-y-0 bg-white",size:"md",emphasis:"subtle",intent:"secondary",children:[e.jsx(h,{className:"h-5 w-5 shrink-0 gap-1 fill-neutral-400"}),"Delete"]})}),e.jsx(f,{title:`Delete Run${s>=2?"s":""}`,handleDelete:i,children:e.jsxs(p,{children:[e.jsx("p",{children:"Are you sure?"}),e.jsx("p",{children:"This action cannot be undone."})]})})]})}function K(){const{selectedRowCount:n}=c();return e.jsxs("div",{className:"flex items-center divide-x divide-theme-border-moderate overflow-hidden rounded-md border border-theme-border-moderate",children:[e.jsx("div",{className:"bg-primary-25 px-2 py-1 font-semibold text-theme-text-brand",children:`${n} Run${n>1?"s":""} selected`}),e.jsx(I,{})]})}export{H as R,K as a,F as b,c as u};
+import{r as l,j as e}from"./@radix-B1sy0Lhr.js";import{L as j,M as R,N as w,O as C,J as b,K as y,B as O}from"./index-Ci5z7q6x.js";import{S as h}from"./trash-D9LA4VFD.js";import{A as v}from"./AlertDialogDropdownItem-DuTp8JFP.js";import{D as f,a as p}from"./DeleteAlertDialog-C5z9RupH.js";import{c as A,u as S}from"./bulk-delete-Bgf_MsSj.js";import{u as T}from"./delete-run-MHYb1wuH.js";const{ContextProvider:F,useContext:c}=A();function m(){const{setRowSelection:n}=c(),{mutateAsync:t}=T();async function s(r){await t({runId:r})}return S({deleteFn:s,queryKeyToInvalidate:["runs"],setRowSelection:n})}function H({id:n}){const[t,s]=l.useState(!1),[r,a]=l.useState(!1),i=l.useRef(null),u=l.useRef(null),{bulkDelete:x}=m();async function D(){await x([n]),d(!1)}function g(){u.current=i.current}function d(o){if(o===!1){a(!1),setTimeout(()=>{s(o)},200);return}s(o)}return e.jsxs(j,{onOpenChange:a,open:r,children:[e.jsx(R,{ref:i,children:e.jsx(w,{className:"h-4 w-4 fill-theme-text-tertiary"})}),e.jsx(C,{hidden:t,onCloseAutoFocus:o=>{u.current&&(u.current.focus(),u.current=null,o.preventDefault())},align:"end",sideOffset:7,children:e.jsx(v,{onSelect:g,open:t,onOpenChange:d,triggerChildren:"Delete",icon:e.jsx(h,{fill:"red"}),children:e.jsx(f,{title:"Delete Run",handleDelete:D,children:e.jsxs(p,{children:[e.jsx("p",{children:"Are you sure?"}),e.jsx("p",{children:"This action cannot be undone."})]})})})})]})}function I(){const[n,t]=l.useState(!1),{selectedRowCount:s,selectedRowIDs:r}=c(),{bulkDelete:a}=m();async function i(){await a(r),t(!1)}return e.jsxs(b,{open:n,onOpenChange:t,children:[e.jsx(y,{asChild:!0,children:e.jsxs(O,{className:"rounded-sharp border-y-0 bg-white",size:"md",emphasis:"subtle",intent:"secondary",children:[e.jsx(h,{className:"h-5 w-5 shrink-0 gap-1 fill-neutral-400"}),"Delete"]})}),e.jsx(f,{title:`Delete Run${s>=2?"s":""}`,handleDelete:i,children:e.jsxs(p,{children:[e.jsx("p",{children:"Are you sure?"}),e.jsx("p",{children:"This action cannot be undone."})]})})]})}function K(){const{selectedRowCount:n}=c();return e.jsxs("div",{className:"flex items-center divide-x divide-theme-border-moderate overflow-hidden rounded-md border border-theme-border-moderate",children:[e.jsx("div",{className:"bg-primary-25 px-2 py-1 font-semibold text-theme-text-brand",children:`${n} Run${n>1?"s":""} selected`}),e.jsx(I,{})]})}export{H as R,K as a,F as b,c as u};