zenml-nightly 0.75.0.dev20250312__py3-none-any.whl → 0.75.0.dev20250314__py3-none-any.whl

zenml/models/__init__.py

@@ -34,13 +34,13 @@ from zenml.models.v2.base.scoped import (
     UserScopedResponse,
     UserScopedResponseBody,
     UserScopedResponseMetadata,
-    WorkspaceScopedRequest,
-    WorkspaceScopedFilter,
-    WorkspaceScopedResponse,
-    WorkspaceScopedResponseBody,
-    WorkspaceScopedResponseMetadata,
-    WorkspaceScopedResponseResources,
-    WorkspaceScopedFilter,
+    ProjectScopedRequest,
+    ProjectScopedFilter,
+    ProjectScopedResponse,
+    ProjectScopedResponseBody,
+    ProjectScopedResponseMetadata,
+    ProjectScopedResponseResources,
+    ProjectScopedFilter,
 )
 from zenml.models.v2.base.filter import (
     BaseFilter,
@@ -133,7 +133,8 @@ from zenml.models.v2.core.component import (
     ComponentResponse,
     ComponentResponseBody,
     ComponentResponseMetadata,
-    ComponentResponseResources
+    ComponentResponseResources,
+    DefaultComponentRequest,
 )
 from zenml.models.v2.core.event_source_flavor import (
     EventSourceFlavorResponse,
@@ -275,6 +276,7 @@ from zenml.models.v2.core.service_connector import (
     ServiceConnectorResponseMetadata,
 )
 from zenml.models.v2.core.stack import (
+    DefaultStackRequest,
     StackRequest,
     StackUpdate,
     StackFilter,
@@ -282,6 +284,10 @@ from zenml.models.v2.core.stack import (
     StackResponseBody,
     StackResponseMetadata,
 )
+from zenml.models.v2.misc.statistics import (
+    ProjectStatistics,
+    ServerStatistics,
+)
 from zenml.models.v2.core.step_run import (
     StepRunRequest,
     StepRunUpdate,
@@ -295,6 +301,7 @@ from zenml.models.v2.core.tag import (
     TagFilter,
     TagResponse,
     TagResponseBody,
+    TagResponseMetadata,
     TagRequest,
     TagUpdate,
 )
@@ -311,13 +318,13 @@ from zenml.models.v2.core.user import (
     UserResponseBody,
     UserResponseMetadata,
 )
-from zenml.models.v2.core.workspace import (
-    WorkspaceRequest,
-    WorkspaceUpdate,
-    WorkspaceFilter,
-    WorkspaceResponse,
-    WorkspaceResponseBody,
-    WorkspaceResponseMetadata,
+from zenml.models.v2.core.project import (
+    ProjectRequest,
+    ProjectUpdate,
+    ProjectFilter,
+    ProjectResponse,
+    ProjectResponseBody,
+    ProjectResponseMetadata,
 )
 
 # V2 Misc
@@ -395,6 +402,9 @@ from zenml.models.v2.misc.stack_deployment import (
     StackDeploymentConfig,
     StackDeploymentInfo,
 )
+from zenml.models.v2.misc.tag import (
+    TagResource,
+)
 from zenml.models.v2.misc.info_models import (
     ComponentInfo,
     ServiceConnectorInfo,
@@ -440,6 +450,7 @@ PipelineDeploymentRequest.model_rebuild()
 PipelineDeploymentResponseBody.model_rebuild()
 PipelineDeploymentResponseMetadata.model_rebuild()
 PipelineDeploymentResponseResources.model_rebuild()
+PipelineRunRequest.model_rebuild()
 PipelineRunResponseBody.model_rebuild()
 PipelineRunResponseMetadata.model_rebuild()
 PipelineRunResponseResources.model_rebuild()
@@ -492,13 +503,13 @@ __all__ = [
     "UserScopedResponse",
     "UserScopedResponseBody",
     "UserScopedResponseMetadata",
-    "WorkspaceScopedRequest",
-    "WorkspaceScopedFilter",
-    "WorkspaceScopedResponse",
-    "WorkspaceScopedResponseBody",
-    "WorkspaceScopedResponseMetadata",
-    "WorkspaceScopedResponseResources",
-    "WorkspaceScopedFilter",
+    "ProjectScopedRequest",
+    "ProjectScopedFilter",
+    "ProjectScopedResponse",
+    "ProjectScopedResponseBody",
+    "ProjectScopedResponseMetadata",
+    "ProjectScopedResponseResources",
+    "ProjectScopedFilter",
     "BaseFilter",
     "StrFilter",
     "BoolFilter",
@@ -562,6 +573,8 @@ __all__ = [
     "ComponentResponseBody",
     "ComponentResponseMetadata",
     "ComponentResponseResources",
+    "DefaultComponentRequest",
+    "DefaultStackRequest",
     "EventSourceFlavorResponse",
     "EventSourceFlavorResponseBody",
     "EventSourceFlavorResponseMetadata",
@@ -695,6 +708,7 @@ __all__ = [
     "TagResourceRequest",
     "TagResponse",
     "TagResponseBody",
+    "TagResponseMetadata",
     "TagRequest",
     "TagUpdate",
     "TriggerResponse",
@@ -723,12 +737,12 @@ __all__ = [
     "UserResponse",
     "UserResponseBody",
     "UserResponseMetadata",
-    "WorkspaceRequest",
-    "WorkspaceUpdate",
-    "WorkspaceFilter",
-    "WorkspaceResponse",
-    "WorkspaceResponseBody",
-    "WorkspaceResponseMetadata",
+    "ProjectRequest",
+    "ProjectUpdate",
+    "ProjectFilter",
+    "ProjectResponse",
+    "ProjectResponseBody",
+    "ProjectResponseMetadata",
     # V2 Misc
     "AuthenticationMethodModel",
     "DeployedStack",
@@ -745,6 +759,7 @@ __all__ = [
     "ServerModel",
     "ServerDatabaseType",
     "ServerDeploymentType",
+    "ServerStatistics",
     "StackDeploymentConfig",
     "StackDeploymentInfo",
     "OAuthDeviceAuthorizationRequest",
@@ -757,7 +772,9 @@ __all__ = [
     "ComponentInfo",
     "ServiceConnectorInfo",
     "ServiceConnectorResourcesInfo",
+    "TagResource",
     "ResourcesInfo",
     "RunMetadataEntry",
     "RunMetadataResource",
+    "ProjectStatistics",
 ]

zenml/models/v2/base/base.py

@@ -65,11 +65,6 @@ class BaseUpdate(BaseZenModel):
     Used as a base class for all update models.
     """
 
-    model_config = ConfigDict(
-        # Ignore extras on all update models.
-        extra="ignore",
-    )
-
 
 # -------------------- Response Model --------------------
 

zenml/models/v2/base/filter.py

@@ -421,7 +421,7 @@ class BaseFilter(BaseModel):
     ```
     ResourceListModel(
         name="contains:default",
-        workspace="default"
+        project="default"
         count_steps="gte:5"
         sort_by="created",
         page=2,
@@ -716,7 +716,7 @@ class BaseFilter(BaseModel):
             value: The filter value.
             table: The table to filter.
             additional_columns: Additional table columns that should also
-                filtered for the given value as part of the or condition.
+                filter for the given value as part of the or condition.
 
         Returns:
             The query conditions.

zenml/models/v2/base/scoped.py

@@ -27,8 +27,9 @@ from typing import (
 )
 from uuid import UUID
 
-from pydantic import Field
+from pydantic import Field, model_validator
 
+from zenml.logger import get_logger
 from zenml.models.v2.base.base import (
     BaseDatedResponseBody,
     BaseIdentifiedResponse,
@@ -41,12 +42,15 @@ from zenml.models.v2.base.filter import AnyQuery, BaseFilter
 if TYPE_CHECKING:
     from sqlalchemy.sql.elements import ColumnElement
 
+    from zenml.models.v2.core.project import ProjectResponse
     from zenml.models.v2.core.user import UserResponse
-    from zenml.models.v2.core.workspace import WorkspaceResponse
     from zenml.zen_stores.schemas import BaseSchema
 
     AnySchema = TypeVar("AnySchema", bound=BaseSchema)
 
+logger = get_logger(__name__)
+
+
 # ---------------------- Request Models ----------------------
 
 
@@ -56,7 +60,14 @@ class UserScopedRequest(BaseRequest):
     Used as a base class for all domain models that are "owned" by a user.
     """
 
-    user: UUID = Field(title="The id of the user that created this resource.")
+    user: Optional[UUID] = Field(
+        default=None,
+        title="The id of the user that created this resource. Set "
+        "automatically by the server.",
+        # This field is set automatically by the server, so the client doesn't
+        # need to set it and it will not be serialized.
+        exclude=True,
+    )
 
     def get_analytics_metadata(self) -> Dict[str, Any]:
         """Fetches the analytics metadata for user scoped models.
@@ -69,24 +80,22 @@ class UserScopedRequest(BaseRequest):
         return metadata
 
 
-class WorkspaceScopedRequest(UserScopedRequest):
-    """Base workspace-scoped request domain model.
+class ProjectScopedRequest(UserScopedRequest):
+    """Base project-scoped request domain model.
 
-    Used as a base class for all domain models that are workspace-scoped.
+    Used as a base class for all domain models that are project-scoped.
     """
 
-    workspace: UUID = Field(
-        title="The workspace to which this resource belongs."
-    )
+    project: UUID = Field(title="The project to which this resource belongs.")
 
     def get_analytics_metadata(self) -> Dict[str, Any]:
-        """Fetches the analytics metadata for workspace scoped models.
+        """Fetches the analytics metadata for project scoped models.
 
         Returns:
             The analytics metadata.
         """
         metadata = super().get_analytics_metadata()
-        metadata["workspace_id"] = self.workspace
+        metadata["project_id"] = self.project
         return metadata
 
 
@@ -157,7 +166,6 @@ class UserScopedFilter(BaseFilter):
     ]
     CLI_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *BaseFilter.CLI_EXCLUDE_FIELDS,
-        "user_id",
         "scope_user",
     ]
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
@@ -169,14 +177,10 @@ class UserScopedFilter(BaseFilter):
         default=None,
         description="The user to scope this query to.",
     )
-    user_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="UUID of the user that created the entity.",
-        union_mode="left_to_right",
-    )
     user: Optional[Union[UUID, str]] = Field(
         default=None,
         description="Name/ID of the user that created the entity.",
+        union_mode="left_to_right",
     )
 
     def set_scope_user(self, user_id: UUID) -> None:
@@ -279,122 +283,82 @@ class UserScopedFilter(BaseFilter):
         return query
 
 
-# Workspace-scoped models
+# Project-scoped models
 
 
-class WorkspaceScopedResponseBody(UserScopedResponseBody):
-    """Base workspace-scoped body."""
+class ProjectScopedResponseBody(UserScopedResponseBody):
+    """Base project-scoped body."""
 
 
-class WorkspaceScopedResponseMetadata(UserScopedResponseMetadata):
-    """Base workspace-scoped metadata."""
+class ProjectScopedResponseMetadata(UserScopedResponseMetadata):
+    """Base project-scoped metadata."""
 
-    workspace: "WorkspaceResponse" = Field(
-        title="The workspace of this resource."
-    )
+    project: "ProjectResponse" = Field(title="The project of this resource.")
 
 
-class WorkspaceScopedResponseResources(UserScopedResponseResources):
-    """Base workspace-scoped resources."""
+class ProjectScopedResponseResources(UserScopedResponseResources):
+    """Base project-scoped resources."""
 
 
-WorkspaceBody = TypeVar("WorkspaceBody", bound=WorkspaceScopedResponseBody)
-WorkspaceMetadata = TypeVar(
-    "WorkspaceMetadata", bound=WorkspaceScopedResponseMetadata
+ProjectBody = TypeVar("ProjectBody", bound=ProjectScopedResponseBody)
+ProjectMetadata = TypeVar(
+    "ProjectMetadata", bound=ProjectScopedResponseMetadata
 )
-WorkspaceResources = TypeVar(
-    "WorkspaceResources", bound=WorkspaceScopedResponseResources
+ProjectResources = TypeVar(
+    "ProjectResources", bound=ProjectScopedResponseResources
 )
 
 
-class WorkspaceScopedResponse(
-    UserScopedResponse[WorkspaceBody, WorkspaceMetadata, WorkspaceResources],
-    Generic[WorkspaceBody, WorkspaceMetadata, WorkspaceResources],
+class ProjectScopedResponse(
+    UserScopedResponse[ProjectBody, ProjectMetadata, ProjectResources],
+    Generic[ProjectBody, ProjectMetadata, ProjectResources],
 ):
-    """Base workspace-scoped domain model.
+    """Base project-scoped domain model.
 
-    Used as a base class for all domain models that are workspace-scoped.
+    Used as a base class for all domain models that are project-scoped.
     """
 
+    # Analytics
+    def get_analytics_metadata(self) -> Dict[str, Any]:
+        """Fetches the analytics metadata for project scoped models.
+
+        Returns:
+            The analytics metadata.
+        """
+        metadata = super().get_analytics_metadata()
+        if self.project is not None:
+            metadata["project_id"] = self.project.id
+        return metadata
+
     # Body and metadata properties
     @property
-    def workspace(self) -> "WorkspaceResponse":
-        """The workspace property.
+    def project(self) -> "ProjectResponse":
+        """The project property.
 
         Returns:
             the value of the property.
         """
-        return self.get_metadata().workspace
+        return self.get_metadata().project
+
+
+# ---------------------- Filter Models ----------------------
 
 
-class WorkspaceScopedFilter(UserScopedFilter):
-    """Model to enable advanced scoping with workspace."""
+class ProjectScopedFilter(UserScopedFilter):
+    """Model to enable advanced scoping with project."""
 
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *UserScopedFilter.FILTER_EXCLUDE_FIELDS,
-        "workspace",
-        "scope_workspace",
+        "project",
     ]
-    CLI_EXCLUDE_FIELDS: ClassVar[List[str]] = [
-        *UserScopedFilter.CLI_EXCLUDE_FIELDS,
-        "workspace_id",
-        "workspace",
-        "scope_workspace",
-    ]
-    CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
-        *UserScopedFilter.CUSTOM_SORTING_OPTIONS,
-        "workspace",
-    ]
-    scope_workspace: Optional[UUID] = Field(
+    project: Optional[Union[UUID, str]] = Field(
         default=None,
-        description="The workspace to scope this query to.",
-    )
-    workspace_id: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="UUID of the workspace that this entity belongs to.",
+        description="Name/ID of the project which the search is scoped to. "
+        "This field must always be set and is always applied in addition to "
+        "the other filters, regardless of the value of the "
+        "logical_operator field.",
         union_mode="left_to_right",
     )
-    workspace: Optional[Union[UUID, str]] = Field(
-        default=None,
-        description="Name/ID of the workspace that this entity belongs to.",
-    )
-
-    def set_scope_workspace(self, workspace_id: UUID) -> None:
-        """Set the workspace to scope this response.
-
-        Args:
-            workspace_id: The workspace to scope this response to.
-        """
-        self.scope_workspace = workspace_id
-
-    def get_custom_filters(
-        self, table: Type["AnySchema"]
-    ) -> List["ColumnElement[bool]"]:
-        """Get custom filters.
-
-        Args:
-            table: The query table.
-
-        Returns:
-            A list of custom filters.
-        """
-        custom_filters = super().get_custom_filters(table)
-
-        from sqlmodel import and_
-
-        from zenml.zen_stores.schemas import WorkspaceSchema
-
-        if self.workspace:
-            workspace_filter = and_(
-                getattr(table, "workspace_id") == WorkspaceSchema.id,
-                self.generate_name_or_id_query_conditions(
-                    value=self.workspace,
-                    table=WorkspaceSchema,
-                ),
-            )
-            custom_filters.append(workspace_filter)
-
-        return custom_filters
 
     def apply_filter(
         self,
@@ -409,59 +373,35 @@ class WorkspaceScopedFilter(UserScopedFilter):
 
         Returns:
             The query with filter applied.
-        """
-        from sqlmodel import or_
 
-        query = super().apply_filter(query=query, table=table)
-
-        if self.scope_workspace:
-            scope_filter = or_(
-                getattr(table, "workspace_id") == self.scope_workspace,
-                getattr(table, "workspace_id").is_(None),
-            )
-            query = query.where(scope_filter)
-
-        return query
-
-    def apply_sorting(
-        self,
-        query: AnyQuery,
-        table: Type["AnySchema"],
-    ) -> AnyQuery:
-        """Apply sorting to the query.
-
-        Args:
-            query: The query to which to apply the sorting.
-            table: The query table.
-
-        Returns:
-            The query with sorting applied.
+        Raises:
+            ValueError: If the project scope is missing from the filter.
         """
-        from sqlmodel import asc, desc
-
-        from zenml.enums import SorterOps
-        from zenml.zen_stores.schemas import WorkspaceSchema
-
-        sort_by, operand = self.sorting_params
-
-        if sort_by == "workspace":
-            column = WorkspaceSchema.name
+        query = super().apply_filter(query=query, table=table)
 
-            query = query.join(
-                WorkspaceSchema,
-                getattr(table, "workspace_id") == WorkspaceSchema.id,
+        # The project scope must always be set and must be a UUID. If the
+        # client sets this to a string, the server will try to resolve it to a
+        # project ID.
+        #
+        # If not set by the client, the server will fall back to using the
+        # user's default project or even the server's default project, if
+        # they are configured. If this also fails to yield a project, this
+        # method will raise a ValueError.
+        #
+        # See: SqlZenStore._set_filter_project_id
+
+        if not self.project:
+            raise ValueError("Project scope missing from the filter.")
+
+        if not isinstance(self.project, UUID):
+            raise ValueError(
+                f"Project scope must be a UUID, got {type(self.project)}."
             )
 
-            query = query.add_columns(WorkspaceSchema.name)
+        scope_filter = getattr(table, "project_id") == self.project
+        query = query.where(scope_filter)
 
-            if operand == SorterOps.ASCENDING:
-                query = query.order_by(asc(column))
-            else:
-                query = query.order_by(desc(column))
-
-            return query
-
-        return super().apply_sorting(query=query, table=table)
+        return query
 
 
 class TaggableFilter(BaseFilter):
@@ -470,16 +410,44 @@ class TaggableFilter(BaseFilter):
     tag: Optional[str] = Field(
         description="Tag to apply to the filter query.", default=None
     )
+    tags: Optional[List[str]] = Field(
+        description="Tags to apply to the filter query.", default=None
+    )
 
+    CLI_EXCLUDE_FIELDS = [
+        *BaseFilter.CLI_EXCLUDE_FIELDS,
+    ]
     FILTER_EXCLUDE_FIELDS: ClassVar[List[str]] = [
         *BaseFilter.FILTER_EXCLUDE_FIELDS,
         "tag",
+        "tags",
     ]
     CUSTOM_SORTING_OPTIONS: ClassVar[List[str]] = [
         *BaseFilter.CUSTOM_SORTING_OPTIONS,
         "tags",
     ]
 
+    @model_validator(mode="after")
+    def add_tag_to_tags(self) -> "TaggableFilter":
+        """Deprecated the tag attribute in favor of the tags attribute.
+
+        Returns:
+            self
+        """
+        if self.tag is not None:
+            logger.warning(
+                "The `tag` attribute is deprecated in favor of the `tags` attribute. "
+                "Please update your code to use the `tags` attribute instead."
+            )
+            if self.tags is not None:
+                self.tags.append(self.tag)
+            else:
+                self.tags = [self.tag]
+
+            self.tag = None
+
+        return self
+
     def apply_filter(
         self,
         query: AnyQuery,
@@ -497,7 +465,8 @@ class TaggableFilter(BaseFilter):
         from zenml.zen_stores.schemas import TagResourceSchema, TagSchema
 
         query = super().apply_filter(query=query, table=table)
-        if self.tag:
+
+        if self.tags:
             query = query.join(
                 TagResourceSchema,
                 TagResourceSchema.resource_id == getattr(table, "id"),
@@ -516,15 +485,25 @@ class TaggableFilter(BaseFilter):
         Returns:
             A list of custom filters.
         """
-        from zenml.zen_stores.schemas import TagSchema
-
         custom_filters = super().get_custom_filters(table)
-        if self.tag:
-            custom_filters.append(
-                self.generate_custom_query_conditions_for_column(
-                    value=self.tag, table=TagSchema, column="name"
+
+        if self.tags:
+            from sqlmodel import exists, select
+
+            from zenml.zen_stores.schemas import TagResourceSchema, TagSchema
+
+            for tag in self.tags:
+                condition = self.generate_custom_query_conditions_for_column(
+                    value=tag, table=TagSchema, column="name"
                 )
-            )
+                exists_subquery = exists(
+                    select(TagResourceSchema)
+                    .join(TagSchema, TagSchema.id == TagResourceSchema.tag_id)  # type: ignore[arg-type]
+                    .where(
+                        TagResourceSchema.resource_id == table.id, condition
+                    )
+                )
+                custom_filters.append(exists_subquery)
 
         return custom_filters