zenml-nightly 0.62.0.dev20240729__py3-none-any.whl → 0.64.0.dev20240809__py3-none-any.whl

zenml/models/v2/core/run_template.py

@@ -0,0 +1,393 @@
+#  Copyright (c) ZenML GmbH 2024. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Models representing pipeline templates."""
+
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union
+from uuid import UUID
+
+from pydantic import Field
+
+from zenml.config.pipeline_spec import PipelineSpec
+from zenml.constants import STR_FIELD_MAX_LENGTH, TEXT_FIELD_MAX_LENGTH
+from zenml.enums import ExecutionStatus
+from zenml.models.v2.base.base import BaseUpdate
+from zenml.models.v2.base.scoped import (
+    WorkspaceScopedRequest,
+    WorkspaceScopedResponse,
+    WorkspaceScopedResponseBody,
+    WorkspaceScopedResponseMetadata,
+    WorkspaceScopedResponseResources,
+    WorkspaceScopedTaggableFilter,
+)
+from zenml.models.v2.core.code_reference import (
+    CodeReferenceResponse,
+)
+from zenml.models.v2.core.pipeline import PipelineResponse
+from zenml.models.v2.core.pipeline_build import (
+    PipelineBuildResponse,
+)
+from zenml.models.v2.core.pipeline_deployment import (
+    PipelineDeploymentResponse,
+)
+from zenml.models.v2.core.tag import TagResponse
+
+if TYPE_CHECKING:
+    from sqlalchemy.sql.elements import ColumnElement
+
+# ------------------ Request Model ------------------
+
+
+class RunTemplateRequest(WorkspaceScopedRequest):
+    """Request model for run templates."""
+
+    name: str = Field(
+        title="The name of the run template.",
+        max_length=STR_FIELD_MAX_LENGTH,
+    )
+    description: Optional[str] = Field(
+        default=None,
+        title="The description of the run template.",
+        max_length=TEXT_FIELD_MAX_LENGTH,
+    )
+    source_deployment_id: UUID = Field(
+        title="The deployment that should be the base of the created template."
+    )
+    tags: Optional[List[str]] = Field(
+        default=None,
+        title="Tags of the run template.",
+    )
+
+
+# ------------------ Update Model ------------------
+
+
+class RunTemplateUpdate(BaseUpdate):
+    """Run template update model."""
+
+    name: Optional[str] = Field(
+        default=None,
+        title="The name of the run template.",
+        max_length=STR_FIELD_MAX_LENGTH,
+    )
+    description: Optional[str] = Field(
+        default=None,
+        title="The description of the run template.",
+        max_length=TEXT_FIELD_MAX_LENGTH,
+    )
+    add_tags: Optional[List[str]] = Field(
+        default=None, title="New tags to add to the run template."
+    )
+    remove_tags: Optional[List[str]] = Field(
+        default=None, title="Tags to remove from the run template."
+    )
+
+
+# ------------------ Response Model ------------------
+
+
+class RunTemplateResponseBody(WorkspaceScopedResponseBody):
+    """Response body for run templates."""
+
+    runnable: bool = Field(
+        title="If a run can be started from the template.",
+    )
+    latest_run_id: Optional[UUID] = Field(
+        default=None,
+        title="The ID of the latest run of the run template.",
+    )
+    latest_run_status: Optional[ExecutionStatus] = Field(
+        default=None,
+        title="The status of the latest run of the run template.",
+    )
+
+
+class RunTemplateResponseMetadata(WorkspaceScopedResponseMetadata):
+    """Response metadata for run templates."""
+
+    description: Optional[str] = Field(
+        default=None,
+        title="The description of the run template.",
+    )
+    pipeline_spec: Optional[PipelineSpec] = Field(
+        default=None, title="The spec of the pipeline."
+    )
+    config_template: Optional[Dict[str, Any]] = Field(
+        default=None, title="Run configuration template."
+    )
+    config_schema: Optional[Dict[str, Any]] = Field(
+        default=None, title="Run configuration schema."
+    )
+
+
+class RunTemplateResponseResources(WorkspaceScopedResponseResources):
+    """All resource models associated with the run template."""
+
+    source_deployment: Optional[PipelineDeploymentResponse] = Field(
+        default=None,
+        title="The deployment that is the source of the template.",
+    )
+    pipeline: Optional[PipelineResponse] = Field(
+        default=None, title="The pipeline associated with the template."
+    )
+    build: Optional[PipelineBuildResponse] = Field(
+        default=None,
+        title="The pipeline build associated with the template.",
+    )
+    code_reference: Optional[CodeReferenceResponse] = Field(
+        default=None,
+        title="The code reference associated with the template.",
+    )
+    tags: List[TagResponse] = Field(
+        title="Tags associated with the run template.",
+    )
+
+
+class RunTemplateResponse(
+    WorkspaceScopedResponse[
+        RunTemplateResponseBody,
+        RunTemplateResponseMetadata,
+        RunTemplateResponseResources,
+    ]
+):
+    """Response model for run templates."""
+
+    name: str = Field(
+        title="The name of the run template.",
+        max_length=STR_FIELD_MAX_LENGTH,
+    )
+
+    def get_hydrated_version(self) -> "RunTemplateResponse":
+        """Return the hydrated version of this run template.
+
+        Returns:
+            The hydrated run template.
+        """
+        from zenml.client import Client
+
+        return Client().zen_store.get_run_template(
+            template_id=self.id, hydrate=True
+        )
+
+    # Body and metadata properties
+    @property
+    def runnable(self) -> bool:
+        """The `runnable` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().runnable
+
+    @property
+    def latest_run_id(self) -> Optional[UUID]:
+        """The `latest_run_id` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().latest_run_id
+
+    @property
+    def latest_run_status(self) -> Optional[ExecutionStatus]:
+        """The `latest_run_status` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().latest_run_status
+
+    @property
+    def description(self) -> Optional[str]:
+        """The `description` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_metadata().description
+
+    @property
+    def pipeline_spec(self) -> Optional[PipelineSpec]:
+        """The `pipeline_spec` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_metadata().pipeline_spec
+
+    @property
+    def config_template(self) -> Optional[Dict[str, Any]]:
+        """The `config_template` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_metadata().config_template
+
+    @property
+    def config_schema(self) -> Optional[Dict[str, Any]]:
+        """The `config_schema` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_metadata().config_schema
+
+    @property
+    def source_deployment(self) -> Optional[PipelineDeploymentResponse]:
+        """The `source_deployment` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_resources().source_deployment
+
+    @property
+    def pipeline(self) -> Optional[PipelineResponse]:
+        """The `pipeline` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_resources().pipeline
+
+    @property
+    def build(self) -> Optional[PipelineBuildResponse]:
+        """The `build` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_resources().build
+
+    @property
+    def code_reference(self) -> Optional[CodeReferenceResponse]:
+        """The `code_reference` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_resources().code_reference
+
+    @property
+    def tags(self) -> List[TagResponse]:
+        """The `tags` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_resources().tags
+
+
+# ------------------ Filter Model ------------------
+
+
+class RunTemplateFilter(WorkspaceScopedTaggableFilter):
+    """Model for filtering of run templates."""
+
+    FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
+        *WorkspaceScopedTaggableFilter.FILTER_EXCLUDE_FIELDS,
+        "code_repository_id",
+        "stack_id",
+        "build_id" "pipeline_id",
+    ]
+
+    name: Optional[str] = Field(
+        default=None,
+        description="Name of the run template.",
+    )
+    workspace_id: Optional[Union[UUID, str]] = Field(
+        default=None,
+        description="Workspace associated with the template.",
+        union_mode="left_to_right",
+    )
+    user_id: Optional[Union[UUID, str]] = Field(
+        default=None,
+        description="User that created the template.",
+        union_mode="left_to_right",
+    )
+    pipeline_id: Optional[Union[UUID, str]] = Field(
+        default=None,
+        description="Pipeline associated with the template.",
+        union_mode="left_to_right",
+    )
+    build_id: Optional[Union[UUID, str]] = Field(
+        default=None,
+        description="Build associated with the template.",
+        union_mode="left_to_right",
+    )
+    stack_id: Optional[Union[UUID, str]] = Field(
+        default=None,
+        description="Stack associated with the template.",
+        union_mode="left_to_right",
+    )
+    code_repository_id: Optional[Union[UUID, str]] = Field(
+        default=None,
+        description="Code repository associated with the template.",
+        union_mode="left_to_right",
+    )
+
+    def get_custom_filters(
+        self,
+    ) -> List["ColumnElement[bool]"]:
+        """Get custom filters.
+
+        Returns:
+            A list of custom filters.
+        """
+        custom_filters = super().get_custom_filters()
+
+        from sqlmodel import and_
+
+        from zenml.zen_stores.schemas import (
+            CodeReferenceSchema,
+            PipelineDeploymentSchema,
+            RunTemplateSchema,
+        )
+
+        if self.code_repository_id:
+            code_repo_filter = and_(
+                RunTemplateSchema.source_deployment_id
+                == PipelineDeploymentSchema.id,
+                PipelineDeploymentSchema.code_reference_id
+                == CodeReferenceSchema.id,
+                CodeReferenceSchema.code_repository_id
+                == self.code_repository_id,
+            )
+            custom_filters.append(code_repo_filter)
+
+        if self.stack_id:
+            stack_filter = and_(
+                RunTemplateSchema.source_deployment_id
+                == PipelineDeploymentSchema.id,
+                PipelineDeploymentSchema.stack_id == self.stack_id,
+            )
+            custom_filters.append(stack_filter)
+
+        if self.build_id:
+            build_filter = and_(
+                RunTemplateSchema.source_deployment_id
+                == PipelineDeploymentSchema.id,
+                PipelineDeploymentSchema.build_id == self.build_id,
+            )
+            custom_filters.append(build_filter)
+
+        if self.pipeline_id:
+            pipeline_filter = and_(
+                RunTemplateSchema.source_deployment_id
+                == PipelineDeploymentSchema.id,
+                PipelineDeploymentSchema.pipeline_id == self.pipeline_id,
+            )
+            custom_filters.append(pipeline_filter)
+
+        return custom_filters

zenml/models/v2/core/server_settings.py

@@ -82,6 +82,9 @@ class ServerSettingsResponseBody(BaseResponseBody):
     display_updates: Optional[bool] = Field(
         title="Whether to display notifications about ZenML updates in the dashboard.",
     )
+    last_user_activity: datetime = Field(
+        title="The timestamp when the last user activity was detected.",
+    )
     updated: datetime = Field(
         title="The timestamp when this resource was last updated."
     )
@@ -179,6 +182,15 @@ class ServerSettingsResponse(
         """
         return self.get_body().active
 
+    @property
+    def last_user_activity(self) -> datetime:
+        """The `last_user_activity` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().last_user_activity
+
     @property
     def updated(self) -> datetime:
         """The `updated` property.

zenml/models/v2/core/user.py

@@ -65,12 +65,6 @@ class UserBase(BaseModel):
         description="`null` if not answered, `true` if agreed, "
         "`false` if skipped.",
     )
-    hub_token: Optional[str] = Field(
-        default=None,
-        title="JWT Token for the connected Hub account. Only relevant for user "
-        "accounts.",
-        max_length=STR_FIELD_MAX_LENGTH,
-    )
     password: Optional[str] = Field(
         default=None,
         title="A password for the user.",
@@ -296,12 +290,6 @@ class UserResponseMetadata(BaseResponseMetadata):
         "for user accounts.",
         max_length=STR_FIELD_MAX_LENGTH,
     )
-    hub_token: Optional[str] = Field(
-        default=None,
-        title="JWT Token for the connected Hub account. Only relevant for user "
-        "accounts.",
-        max_length=STR_FIELD_MAX_LENGTH,
-    )
     external_user_id: Optional[UUID] = Field(
         default=None,
         title="The external user ID associated with the account. Only relevant "
@@ -416,15 +404,6 @@ class UserResponse(
         """
         return self.get_metadata().email
 
-    @property
-    def hub_token(self) -> Optional[str]:
-        """The `hub_token` property.
-
-        Returns:
-            the value of the property.
-        """
-        return self.get_metadata().hub_token
-
     @property
     def external_user_id(self) -> Optional[UUID]:
         """The `external_user_id` property.

zenml/models/v2/misc/server_models.py

@@ -13,7 +13,8 @@
 #  permissions and limitations under the License.
 """Model definitions for ZenML servers."""
 
-from typing import Dict
+from datetime import datetime
+from typing import Dict, Optional
 from uuid import UUID, uuid4
 
 from pydantic import BaseModel, Field
@@ -103,6 +104,11 @@ class ServerModel(BaseModel):
         title="Flag to indicate whether the server is using the legacy dashboard.",
     )
 
+    last_user_activity: Optional[datetime] = Field(
+        None,
+        title="Timestamp of latest user activity traced on the server.",
+    )
+
     def is_local(self) -> bool:
         """Return whether the server is running locally.
 

zenml/models/v2/misc/stack_deployment.py

@@ -72,9 +72,14 @@ class StackDeploymentConfig(BaseModel):
         title="A textual description for the cloud provider console URL.",
     )
     configuration: Optional[str] = Field(
+        default=None,
         title="Configuration for the stack deployment that the user must "
         "manually configure into the cloud provider console.",
     )
+    instructions: Optional[str] = Field(
+        default=None,
+        title="Instructions for deploying the stack.",
+    )
 
 
 class DeployedStack(BaseModel):

zenml/models/v2/misc/user_auth.py

@@ -73,13 +73,6 @@ class UserAuthModel(BaseZenModel):
         "`false` if skipped.",
     )
 
-    hub_token: Optional[str] = Field(
-        default=None,
-        title="JWT Token for the connected Hub account. Only relevant for user "
-        "accounts.",
-        max_length=STR_FIELD_MAX_LENGTH,
-    )
-
     @classmethod
     def _get_crypt_context(cls) -> "CryptContext":
         """Returns the password encryption context.