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

zenml/zen_stores/schemas/model_schemas.py

@@ -12,14 +12,26 @@
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
 """SQLModel implementation of model tables."""
-from datetime import datetime
-from typing import Dict, List, Optional
-from uuid import UUID
 
-from sqlalchemy import BOOLEAN, INTEGER, TEXT, Column
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from uuid import UUID, uuid4
+
+from pydantic import ConfigDict
+from sqlalchemy import (
+    BOOLEAN,
+    INTEGER,
+    TEXT,
+    Column,
+    UniqueConstraint,
+)
 from sqlmodel import Field, Relationship
 
-from zenml.enums import MetadataResourceTypes, TaggableResourceTypes
+from zenml.enums import (
+    ArtifactType,
+    MetadataResourceTypes,
+    TaggableResourceTypes,
+)
 from zenml.models import (
     BaseResponseMetadata,
     ModelRequest,
@@ -37,21 +49,38 @@ from zenml.models import (
     ModelVersionResponse,
     ModelVersionResponseBody,
     ModelVersionResponseMetadata,
+    ModelVersionResponseResources,
+    Page,
 )
 from zenml.zen_stores.schemas.artifact_schemas import ArtifactVersionSchema
 from zenml.zen_stores.schemas.base_schemas import BaseSchema, NamedSchema
+from zenml.zen_stores.schemas.constants import MODEL_VERSION_TABLENAME
 from zenml.zen_stores.schemas.pipeline_run_schemas import PipelineRunSchema
 from zenml.zen_stores.schemas.run_metadata_schemas import RunMetadataSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
-from zenml.zen_stores.schemas.tag_schemas import TagResourceSchema
+from zenml.zen_stores.schemas.tag_schemas import TagSchema
 from zenml.zen_stores.schemas.user_schemas import UserSchema
+from zenml.zen_stores.schemas.utils import (
+    RunMetadataInterface,
+    get_page_from_list,
+)
 from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
+if TYPE_CHECKING:
+    from zenml.zen_stores.schemas import ServiceSchema, StepRunSchema
+
 
 class ModelSchema(NamedSchema, table=True):
     """SQL Model for model."""
 
     __tablename__ = "model"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            "workspace_id",
+            name="unique_model_name_in_workspace",
+        ),
+    )
 
     workspace_id: UUID = build_foreign_key_field(
         source=__tablename__,
@@ -83,11 +112,12 @@ class ModelSchema(NamedSchema, table=True):
     save_models_to_registry: bool = Field(
         sa_column=Column(BOOLEAN, nullable=False)
     )
-    tags: List["TagResourceSchema"] = Relationship(
-        back_populates="model",
+    tags: List["TagSchema"] = Relationship(
         sa_relationship_kwargs=dict(
-            primaryjoin=f"and_(TagResourceSchema.resource_type=='{TaggableResourceTypes.MODEL.value}', foreign(TagResourceSchema.resource_id)==ModelSchema.id)",
-            cascade="delete",
+            primaryjoin=f"and_(foreign(TagResourceSchema.resource_type)=='{TaggableResourceTypes.MODEL.value}', foreign(TagResourceSchema.resource_id)==ModelSchema.id)",
+            secondary="tag_resource",
+            secondaryjoin="TagSchema.id == foreign(TagResourceSchema.tag_id)",
+            order_by="TagSchema.name",
             overlaps="tags",
         ),
     )
@@ -95,14 +125,6 @@ class ModelSchema(NamedSchema, table=True):
         back_populates="model",
         sa_relationship_kwargs={"cascade": "delete"},
     )
-    artifact_links: List["ModelVersionArtifactSchema"] = Relationship(
-        back_populates="model",
-        sa_relationship_kwargs={"cascade": "delete"},
-    )
-    pipeline_run_links: List["ModelVersionPipelineRunSchema"] = Relationship(
-        back_populates="model",
-        sa_relationship_kwargs={"cascade": "delete"},
-    )
 
     @classmethod
     def from_request(cls, model_request: ModelRequest) -> "ModelSchema":
@@ -130,18 +152,22 @@ class ModelSchema(NamedSchema, table=True):
 
     def to_model(
         self,
-        hydrate: bool = False,
+        include_metadata: bool = False,
+        include_resources: bool = False,
+        **kwargs: Any,
     ) -> ModelResponse:
         """Convert an `ModelSchema` to an `ModelResponse`.
 
         Args:
-            hydrate: bool to decide whether to return a hydrated version of the
-                model.
+            include_metadata: Whether the metadata will be filled.
+            include_resources: Whether the resources will be filled.
+            **kwargs: Keyword arguments to allow schema specific logic
+
 
         Returns:
             The created `ModelResponse`.
         """
-        tags = [t.tag.to_model() for t in self.tags]
+        tags = [tag.to_model() for tag in self.tags]
 
         if self.model_versions:
             version_numbers = [mv.number for mv in self.model_versions]
@@ -153,7 +179,7 @@ class ModelSchema(NamedSchema, table=True):
             latest_version_id = None
 
         metadata = None
-        if hydrate:
+        if include_metadata:
             metadata = ModelResponseMetadata(
                 workspace=self.workspace.to_model(),
                 license=self.license,
@@ -168,7 +194,6 @@ class ModelSchema(NamedSchema, table=True):
 
         body = ModelResponseBody(
             user=self.user.to_model() if self.user else None,
-            workspace=self.workspace.to_model(),
             created=self.created,
             updated=self.updated,
             tags=tags,
@@ -195,7 +220,7 @@ class ModelSchema(NamedSchema, table=True):
         Returns:
             The updated `ModelSchema`.
         """
-        for field, value in model_update.dict(
+        for field, value in model_update.model_dump(
             exclude_unset=True, exclude_none=True
         ).items():
             setattr(self, field, value)
@@ -203,10 +228,34 @@ class ModelSchema(NamedSchema, table=True):
         return self
 
 
-class ModelVersionSchema(NamedSchema, table=True):
+class ModelVersionSchema(NamedSchema, RunMetadataInterface, table=True):
     """SQL Model for model version."""
 
-    __tablename__ = "model_version"
+    __tablename__ = MODEL_VERSION_TABLENAME
+    __table_args__ = (
+        # We need three unique constraints here:
+        # - The first to ensure that each model version for a
+        #   model has a unique version number
+        # - The second one to ensure that explicit names given by
+        #   users are unique
+        # - The third one to ensure that a pipeline run only produces a single
+        #   auto-incremented version per model
+        UniqueConstraint(
+            "number",
+            "model_id",
+            name="unique_version_number_for_model_id",
+        ),
+        UniqueConstraint(
+            "name",
+            "model_id",
+            name="unique_version_for_model_id",
+        ),
+        UniqueConstraint(
+            "model_id",
+            "producer_run_id_if_numeric",
+            name="unique_numeric_version_for_pipeline_run",
+        ),
+    )
 
     workspace_id: UUID = build_foreign_key_field(
         source=__tablename__,
@@ -249,63 +298,111 @@ class ModelVersionSchema(NamedSchema, table=True):
         back_populates="model_version",
         sa_relationship_kwargs={"cascade": "delete"},
     )
-    tags: List["TagResourceSchema"] = Relationship(
-        back_populates="model_version",
+    tags: List["TagSchema"] = Relationship(
         sa_relationship_kwargs=dict(
-            primaryjoin=f"and_(TagResourceSchema.resource_type=='{TaggableResourceTypes.MODEL_VERSION.value}', foreign(TagResourceSchema.resource_id)==ModelVersionSchema.id)",
-            cascade="delete",
+            primaryjoin=f"and_(foreign(TagResourceSchema.resource_type)=='{TaggableResourceTypes.MODEL_VERSION.value}', foreign(TagResourceSchema.resource_id)==ModelVersionSchema.id)",
+            secondary="tag_resource",
+            secondaryjoin="TagSchema.id == foreign(TagResourceSchema.tag_id)",
+            order_by="TagSchema.name",
             overlaps="tags",
         ),
     )
 
+    services: List["ServiceSchema"] = Relationship(
+        back_populates="model_version",
+    )
+
     number: int = Field(sa_column=Column(INTEGER, nullable=False))
     description: str = Field(sa_column=Column(TEXT, nullable=True))
     stage: str = Field(sa_column=Column(TEXT, nullable=True))
 
     run_metadata: List["RunMetadataSchema"] = Relationship(
-        back_populates="model_version",
         sa_relationship_kwargs=dict(
-            primaryjoin=f"and_(RunMetadataSchema.resource_type=='{MetadataResourceTypes.MODEL_VERSION.value}', foreign(RunMetadataSchema.resource_id)==ModelVersionSchema.id)",
-            cascade="delete",
+            secondary="run_metadata_resource",
+            primaryjoin=f"and_(foreign(RunMetadataResourceSchema.resource_type)=='{MetadataResourceTypes.MODEL_VERSION.value}', foreign(RunMetadataResourceSchema.resource_id)==ModelVersionSchema.id)",
+            secondaryjoin="RunMetadataSchema.id==foreign(RunMetadataResourceSchema.run_metadata_id)",
             overlaps="run_metadata",
         ),
     )
+    pipeline_runs: List["PipelineRunSchema"] = Relationship(
+        back_populates="model_version",
+    )
+    step_runs: List["StepRunSchema"] = Relationship(
+        back_populates="model_version"
+    )
+
+    # We want to make sure each pipeline run only creates a single numeric
+    # version for each model. To solve this, we need to add a unique constraint.
+    # If a value of a unique constraint is NULL it is ignored and the
+    # remaining values in the unique constraint have to be unique. In
+    # our case however, we only want the unique constraint applied in
+    # case there is a producer run and only for numeric versions. To solve this,
+    # we fall back to the model version ID (which is the primary key and
+    # therefore unique) in case there is no producer run or the version is not
+    # numeric.
+    producer_run_id_if_numeric: UUID
+
+    # TODO: In Pydantic v2, the `model_` is a protected namespaces for all
+    #  fields defined under base models. If not handled, this raises a warning.
+    #  It is possible to suppress this warning message with the following
+    #  configuration, however the ultimate solution is to rename these fields.
+    #  Even though they do not cause any problems right now, if we are not
+    #  careful we might overwrite some fields protected by pydantic.
+    model_config = ConfigDict(protected_namespaces=())  # type: ignore[assignment]
 
     @classmethod
     def from_request(
-        cls, model_version_request: ModelVersionRequest
+        cls,
+        model_version_request: ModelVersionRequest,
+        model_version_number: int,
+        producer_run_id: Optional[UUID] = None,
     ) -> "ModelVersionSchema":
         """Convert an `ModelVersionRequest` to an `ModelVersionSchema`.
 
         Args:
             model_version_request: The request model version to convert.
+            model_version_number: The model version number.
+            producer_run_id: The ID of the producer run.
 
         Returns:
             The converted schema.
         """
+        id_ = uuid4()
+        is_numeric = str(model_version_number) == model_version_request.name
+
         return cls(
+            id=id_,
             workspace_id=model_version_request.workspace,
             user_id=model_version_request.user,
             model_id=model_version_request.model,
             name=model_version_request.name,
-            number=model_version_request.number,
+            number=model_version_number,
             description=model_version_request.description,
             stage=model_version_request.stage,
+            producer_run_id_if_numeric=producer_run_id
+            if (producer_run_id and is_numeric)
+            else id_,
         )
 
     def to_model(
         self,
-        hydrate: bool = False,
+        include_metadata: bool = False,
+        include_resources: bool = False,
+        **kwargs: Any,
     ) -> ModelVersionResponse:
         """Convert an `ModelVersionSchema` to an `ModelVersionResponse`.
 
         Args:
-            hydrate: bool to decide whether to return a hydrated version of the
-                model.
+            include_metadata: Whether the metadata will be filled.
+            include_resources: Whether the resources will be filled.
+            **kwargs: Keyword arguments to allow schema specific logic
+
 
         Returns:
             The created `ModelVersionResponse`.
         """
+        from zenml.models import ServiceResponse
+
         # Construct {name: {version: id}} dicts for all linked artifacts
         model_artifact_ids: Dict[str, Dict[str, UUID]] = {}
         deployment_artifact_ids: Dict[str, Dict[str, UUID]] = {}
@@ -316,11 +413,14 @@ class ModelVersionSchema(NamedSchema, table=True):
             artifact_name = artifact_link.artifact_version.artifact.name
             artifact_version = str(artifact_link.artifact_version.version)
             artifact_version_id = artifact_link.artifact_version.id
-            if artifact_link.is_model_artifact:
+            if artifact_link.artifact_version.type == ArtifactType.MODEL.value:
                 model_artifact_ids.setdefault(artifact_name, {}).update(
                     {str(artifact_version): artifact_version_id}
                 )
-            elif artifact_link.is_deployment_artifact:
+            elif (
+                artifact_link.artifact_version.type
+                == ArtifactType.SERVICE.value
+            ):
                 deployment_artifact_ids.setdefault(artifact_name, {}).update(
                     {str(artifact_version): artifact_version_id}
                 )
@@ -338,15 +438,26 @@ class ModelVersionSchema(NamedSchema, table=True):
             pipeline_run_ids[pipeline_run.name] = pipeline_run.id
 
         metadata = None
-
-        if hydrate:
+        if include_metadata:
             metadata = ModelVersionResponseMetadata(
                 workspace=self.workspace.to_model(),
                 description=self.description,
-                run_metadata={
-                    rm.key: rm.to_model(hydrate=True)
-                    for rm in self.run_metadata
-                },
+                run_metadata=self.fetch_metadata(),
+            )
+
+        resources = None
+        if include_resources:
+            services = cast(
+                Page[ServiceResponse],
+                get_page_from_list(
+                    items_list=self.services,
+                    response_model=ServiceResponse,
+                    include_resources=include_resources,
+                    include_metadata=include_metadata,
+                ),
+            )
+            resources = ModelVersionResponseResources(
+                services=services,
             )
 
         body = ModelVersionResponseBody(
@@ -360,7 +471,7 @@ class ModelVersionSchema(NamedSchema, table=True):
             data_artifact_ids=data_artifact_ids,
             deployment_artifact_ids=deployment_artifact_ids,
             pipeline_run_ids=pipeline_run_ids,
-            tags=[t.tag.to_model() for t in self.tags],
+            tags=[tag.to_model() for tag in self.tags],
         )
 
         return ModelVersionResponse(
@@ -368,6 +479,7 @@ class ModelVersionSchema(NamedSchema, table=True):
             name=self.name,
             body=body,
             metadata=metadata,
+            resources=resources,
         )
 
     def update(
@@ -401,39 +513,6 @@ class ModelVersionArtifactSchema(BaseSchema, table=True):
 
     __tablename__ = "model_versions_artifacts"
 
-    workspace_id: UUID = build_foreign_key_field(
-        source=__tablename__,
-        target=WorkspaceSchema.__tablename__,
-        source_column="workspace_id",
-        target_column="id",
-        ondelete="CASCADE",
-        nullable=False,
-    )
-    workspace: "WorkspaceSchema" = Relationship(
-        back_populates="model_versions_artifacts_links"
-    )
-
-    user_id: Optional[UUID] = build_foreign_key_field(
-        source=__tablename__,
-        target=UserSchema.__tablename__,
-        source_column="user_id",
-        target_column="id",
-        ondelete="SET NULL",
-        nullable=True,
-    )
-    user: Optional["UserSchema"] = Relationship(
-        back_populates="model_versions_artifacts_links"
-    )
-
-    model_id: UUID = build_foreign_key_field(
-        source=__tablename__,
-        target=ModelSchema.__tablename__,
-        source_column="model_id",
-        target_column="id",
-        ondelete="CASCADE",
-        nullable=False,
-    )
-    model: "ModelSchema" = Relationship(back_populates="artifact_links")
     model_version_id: UUID = build_foreign_key_field(
         source=__tablename__,
         target=ModelVersionSchema.__tablename__,
@@ -447,7 +526,7 @@ class ModelVersionArtifactSchema(BaseSchema, table=True):
     )
     artifact_version_id: UUID = build_foreign_key_field(
         source=__tablename__,
-        target=ArtifactVersionSchema.__tablename__,
+        target=ArtifactVersionSchema.__tablename__,  # type: ignore[has-type]
         source_column="artifact_version_id",
         target_column="id",
         ondelete="CASCADE",
@@ -457,10 +536,13 @@ class ModelVersionArtifactSchema(BaseSchema, table=True):
         back_populates="model_versions_artifacts_links"
     )
 
-    is_model_artifact: bool = Field(sa_column=Column(BOOLEAN, nullable=True))
-    is_deployment_artifact: bool = Field(
-        sa_column=Column(BOOLEAN, nullable=True)
-    )
+    # TODO: In Pydantic v2, the `model_` is a protected namespaces for all
+    #  fields defined under base models. If not handled, this raises a warning.
+    #  It is possible to suppress this warning message with the following
+    #  configuration, however the ultimate solution is to rename these fields.
+    #  Even though they do not cause any problems right now, if we are not
+    #  careful we might overwrite some fields protected by pydantic.
+    model_config = ConfigDict(protected_namespaces=())  # type: ignore[assignment]
 
     @classmethod
     def from_request(
@@ -476,24 +558,23 @@ class ModelVersionArtifactSchema(BaseSchema, table=True):
             The converted schema.
         """
         return cls(
-            workspace_id=model_version_artifact_request.workspace,
-            user_id=model_version_artifact_request.user,
-            model_id=model_version_artifact_request.model,
             model_version_id=model_version_artifact_request.model_version,
             artifact_version_id=model_version_artifact_request.artifact_version,
-            is_model_artifact=model_version_artifact_request.is_model_artifact,
-            is_deployment_artifact=model_version_artifact_request.is_deployment_artifact,
         )
 
     def to_model(
         self,
-        hydrate: bool = False,
+        include_metadata: bool = False,
+        include_resources: bool = False,
+        **kwargs: Any,
     ) -> ModelVersionArtifactResponse:
         """Convert an `ModelVersionArtifactSchema` to an `ModelVersionArtifactResponse`.
 
         Args:
-            hydrate: bool to decide whether to return a hydrated version of the
-                model.
+            include_metadata: Whether the metadata will be filled.
+            include_resources: Whether the resources will be filled.
+            **kwargs: Keyword arguments to allow schema specific logic
+
 
         Returns:
             The created `ModelVersionArtifactResponseModel`.
@@ -503,13 +584,10 @@ class ModelVersionArtifactSchema(BaseSchema, table=True):
             body=ModelVersionArtifactResponseBody(
                 created=self.created,
                 updated=self.updated,
-                model=self.model_id,
                 model_version=self.model_version_id,
                 artifact_version=self.artifact_version.to_model(),
-                is_model_artifact=self.is_model_artifact,
-                is_deployment_artifact=self.is_deployment_artifact,
             ),
-            metadata=BaseResponseMetadata() if hydrate else None,
+            metadata=BaseResponseMetadata() if include_metadata else None,
         )
 
 
@@ -518,39 +596,6 @@ class ModelVersionPipelineRunSchema(BaseSchema, table=True):
 
     __tablename__ = "model_versions_runs"
 
-    workspace_id: UUID = build_foreign_key_field(
-        source=__tablename__,
-        target=WorkspaceSchema.__tablename__,
-        source_column="workspace_id",
-        target_column="id",
-        ondelete="CASCADE",
-        nullable=False,
-    )
-    workspace: "WorkspaceSchema" = Relationship(
-        back_populates="model_versions_pipeline_runs_links"
-    )
-
-    user_id: Optional[UUID] = build_foreign_key_field(
-        source=__tablename__,
-        target=UserSchema.__tablename__,
-        source_column="user_id",
-        target_column="id",
-        ondelete="SET NULL",
-        nullable=True,
-    )
-    user: Optional["UserSchema"] = Relationship(
-        back_populates="model_versions_pipeline_runs_links"
-    )
-
-    model_id: UUID = build_foreign_key_field(
-        source=__tablename__,
-        target=ModelSchema.__tablename__,
-        source_column="model_id",
-        target_column="id",
-        ondelete="CASCADE",
-        nullable=False,
-    )
-    model: "ModelSchema" = Relationship(back_populates="pipeline_run_links")
     model_version_id: UUID = build_foreign_key_field(
         source=__tablename__,
         target=ModelVersionSchema.__tablename__,
@@ -574,6 +619,14 @@ class ModelVersionPipelineRunSchema(BaseSchema, table=True):
         back_populates="model_versions_pipeline_runs_links"
     )
 
+    # TODO: In Pydantic v2, the `model_` is a protected namespaces for all
+    #  fields defined under base models. If not handled, this raises a warning.
+    #  It is possible to suppress this warning message with the following
+    #  configuration, however the ultimate solution is to rename these fields.
+    #  Even though they do not cause any problems right now, if we are not
+    #  careful we might overwrite some fields protected by pydantic.
+    model_config = ConfigDict(protected_namespaces=())  # type: ignore[assignment]
+
     @classmethod
     def from_request(
         cls,
@@ -588,22 +641,23 @@ class ModelVersionPipelineRunSchema(BaseSchema, table=True):
             The converted schema.
         """
         return cls(
-            workspace_id=model_version_pipeline_run_request.workspace,
-            user_id=model_version_pipeline_run_request.user,
-            model_id=model_version_pipeline_run_request.model,
             model_version_id=model_version_pipeline_run_request.model_version,
             pipeline_run_id=model_version_pipeline_run_request.pipeline_run,
         )
 
     def to_model(
         self,
-        hydrate: bool = False,
+        include_metadata: bool = False,
+        include_resources: bool = False,
+        **kwargs: Any,
     ) -> ModelVersionPipelineRunResponse:
         """Convert an `ModelVersionPipelineRunSchema` to an `ModelVersionPipelineRunResponse`.
 
         Args:
-            hydrate: bool to decide whether to return a hydrated version of the
-                model.
+            include_metadata: Whether the metadata will be filled.
+            include_resources: Whether the resources will be filled.
+            **kwargs: Keyword arguments to allow schema specific logic
+
 
         Returns:
             The created `ModelVersionPipelineRunResponse`.
@@ -613,9 +667,8 @@ class ModelVersionPipelineRunSchema(BaseSchema, table=True):
             body=ModelVersionPipelineRunResponseBody(
                 created=self.created,
                 updated=self.updated,
-                model=self.model_id,
                 model_version=self.model_version_id,
                 pipeline_run=self.pipeline_run.to_model(),
             ),
-            metadata=BaseResponseMetadata() if hydrate else None,
+            metadata=BaseResponseMetadata() if include_metadata else None,
         )

zenml/zen_stores/schemas/pipeline_build_schemas.py

@@ -13,12 +13,10 @@
 #  permissions and limitations under the License.
 """SQLModel implementation of pipeline build tables."""
 
-
 import json
-from typing import TYPE_CHECKING, List, Optional
+from typing import Any, Optional
 from uuid import UUID
 
-from pydantic.json import pydantic_encoder
 from sqlalchemy import Column, String
 from sqlalchemy.dialects.mysql import MEDIUMTEXT
 from sqlmodel import Field, Relationship
@@ -30,6 +28,7 @@ from zenml.models import (
     PipelineBuildResponseBody,
     PipelineBuildResponseMetadata,
 )
+from zenml.utils.json_utils import pydantic_encoder
 from zenml.zen_stores.schemas.base_schemas import BaseSchema
 from zenml.zen_stores.schemas.pipeline_schemas import PipelineSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
@@ -37,11 +36,6 @@ from zenml.zen_stores.schemas.stack_schemas import StackSchema
 from zenml.zen_stores.schemas.user_schemas import UserSchema
 from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
-if TYPE_CHECKING:
-    from zenml.zen_stores.schemas.pipeline_deployment_schemas import (
-        PipelineDeploymentSchema,
-    )
-
 
 class PipelineBuildSchema(BaseSchema, table=True):
     """SQL Model for pipeline builds."""
@@ -90,10 +84,6 @@ class PipelineBuildSchema(BaseSchema, table=True):
         back_populates="builds"
     )
 
-    deployments: List["PipelineDeploymentSchema"] = Relationship(
-        back_populates="build",
-    )
-
     images: str = Field(
         sa_column=Column(
             String(length=MEDIUMTEXT_MAX_LENGTH).with_variant(
@@ -109,6 +99,7 @@ class PipelineBuildSchema(BaseSchema, table=True):
     zenml_version: Optional[str]
     python_version: Optional[str]
     checksum: Optional[str]
+    stack_checksum: Optional[str]
 
     @classmethod
     def from_request(
@@ -133,14 +124,22 @@ class PipelineBuildSchema(BaseSchema, table=True):
             zenml_version=request.zenml_version,
             python_version=request.python_version,
             checksum=request.checksum,
+            stack_checksum=request.stack_checksum,
         )
 
-    def to_model(self, hydrate: bool = False) -> PipelineBuildResponse:
+    def to_model(
+        self,
+        include_metadata: bool = False,
+        include_resources: bool = False,
+        **kwargs: Any,
+    ) -> PipelineBuildResponse:
         """Convert a `PipelineBuildSchema` to a `PipelineBuildResponse`.
 
         Args:
-            hydrate: bool to decide whether to return a hydrated version of the
-                model.
+            include_metadata: Whether the metadata will be filled.
+            include_resources: Whether the resources will be filled.
+            **kwargs: Keyword arguments to allow schema specific logic
+
 
         Returns:
             The created `PipelineBuildResponse`.
@@ -151,7 +150,7 @@ class PipelineBuildSchema(BaseSchema, table=True):
             updated=self.updated,
         )
         metadata = None
-        if hydrate:
+        if include_metadata:
             metadata = PipelineBuildResponseMetadata(
                 workspace=self.workspace.to_model(),
                 pipeline=self.pipeline.to_model() if self.pipeline else None,
@@ -160,6 +159,7 @@ class PipelineBuildSchema(BaseSchema, table=True):
                 zenml_version=self.zenml_version,
                 python_version=self.python_version,
                 checksum=self.checksum,
+                stack_checksum=self.stack_checksum,
                 is_local=self.is_local,
                 contains_code=self.contains_code,
             )