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

zenml/zen_stores/schemas/schedule_schema.py

@@ -17,6 +17,7 @@ from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any, List, Optional
 from uuid import UUID
 
+from sqlalchemy import UniqueConstraint
 from sqlmodel import Field, Relationship
 
 from zenml.enums import MetadataResourceTypes
@@ -31,10 +32,10 @@ from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.base_schemas import NamedSchema
 from zenml.zen_stores.schemas.component_schemas import StackComponentSchema
 from zenml.zen_stores.schemas.pipeline_schemas import PipelineSchema
+from zenml.zen_stores.schemas.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 from zenml.zen_stores.schemas.user_schemas import UserSchema
 from zenml.zen_stores.schemas.utils import RunMetadataInterface
-from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
 if TYPE_CHECKING:
     from zenml.zen_stores.schemas.pipeline_deployment_schemas import (
@@ -49,16 +50,23 @@ class ScheduleSchema(NamedSchema, RunMetadataInterface, table=True):
     """SQL Model for schedules."""
 
     __tablename__ = "schedule"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            "project_id",
+            name="unique_schedule_name_in_project",
+        ),
+    )
 
-    workspace_id: UUID = build_foreign_key_field(
+    project_id: UUID = build_foreign_key_field(
         source=__tablename__,
-        target=WorkspaceSchema.__tablename__,
-        source_column="workspace_id",
+        target=ProjectSchema.__tablename__,
+        source_column="project_id",
         target_column="id",
         ondelete="CASCADE",
         nullable=False,
     )
-    workspace: "WorkspaceSchema" = Relationship(back_populates="schedules")
+    project: "ProjectSchema" = Relationship(back_populates="schedules")
 
     user_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
@@ -130,7 +138,7 @@ class ScheduleSchema(NamedSchema, RunMetadataInterface, table=True):
             interval_second = None
         return cls(
             name=schedule_request.name,
-            workspace_id=schedule_request.workspace,
+            project_id=schedule_request.project,
             user_id=schedule_request.user,
             pipeline_id=schedule_request.pipeline_id,
             orchestrator_id=schedule_request.orchestrator_id,
@@ -154,20 +162,7 @@ class ScheduleSchema(NamedSchema, RunMetadataInterface, table=True):
         """
         if schedule_update.name is not None:
             self.name = schedule_update.name
-        if schedule_update.active is not None:
-            self.active = schedule_update.active
-        if schedule_update.cron_expression is not None:
-            self.cron_expression = schedule_update.cron_expression
-        if schedule_update.start_time is not None:
-            self.start_time = schedule_update.start_time
-        if schedule_update.end_time is not None:
-            self.end_time = schedule_update.end_time
-        if schedule_update.interval_second is not None:
-            self.interval_second = (
-                schedule_update.interval_second.total_seconds()
-            )
-        if schedule_update.catchup is not None:
-            self.catchup = schedule_update.catchup
+
         self.updated = utc_now()
         return self
 
@@ -208,7 +203,7 @@ class ScheduleSchema(NamedSchema, RunMetadataInterface, table=True):
         metadata = None
         if include_metadata:
             metadata = ScheduleResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 pipeline_id=self.pipeline_id,
                 orchestrator_id=self.orchestrator_id,
                 run_metadata=self.fetch_metadata(),

zenml/zen_stores/schemas/secret_schemas.py

@@ -18,7 +18,7 @@ import json
 from typing import Any, Dict, Optional, cast
 from uuid import UUID
 
-from sqlalchemy import TEXT, Column
+from sqlalchemy import TEXT, Column, UniqueConstraint
 from sqlalchemy_utils.types.encrypted.encrypted_type import (
     AesGcmEngine,
     InvalidCiphertextError,
@@ -26,7 +26,6 @@ from sqlalchemy_utils.types.encrypted.encrypted_type import (
 from sqlmodel import Field, Relationship
 
 from zenml.constants import TEXT_FIELD_MAX_LENGTH
-from zenml.enums import SecretScope
 from zenml.models import (
     SecretRequest,
     SecretResponse,
@@ -38,7 +37,6 @@ from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.base_schemas import NamedSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 from zenml.zen_stores.schemas.user_schemas import UserSchema
-from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
 
 class SecretDecodeError(Exception):
@@ -54,21 +52,19 @@ class SecretSchema(NamedSchema, table=True):
     """
 
     __tablename__ = "secret"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            "private",
+            "user_id",
+            name="unique_secret_name_private_scope_user",
+        ),
+    )
 
-    scope: str
+    private: bool
 
     values: Optional[bytes] = Field(sa_column=Column(TEXT, nullable=True))
 
-    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="secrets")
-
     user_id: UUID = build_foreign_key_field(
         source=__tablename__,
         target=UserSchema.__tablename__,
@@ -177,8 +173,7 @@ class SecretSchema(NamedSchema, table=True):
         assert secret.user is not None, "User must be set for secret creation."
         return cls(
             name=secret.name,
-            scope=secret.scope.value,
-            workspace_id=secret.workspace,
+            private=secret.private,
             user_id=secret.user,
             # Don't store secret values implicitly in the secret. The
             # SQL secret store will call `store_secret_values` to store the
@@ -202,12 +197,9 @@ class SecretSchema(NamedSchema, table=True):
         # SQL secret store will call `set_secret_values` to update the
         # values separately if SQL is used as the secrets store.
         for field, value in secret_update.model_dump(
-            exclude_unset=True, exclude={"workspace", "user", "values"}
+            exclude_unset=True, exclude={"user", "values"}
         ).items():
-            if field == "scope":
-                setattr(self, field, value.value)
-            else:
-                setattr(self, field, value)
+            setattr(self, field, value)
 
         self.updated = utc_now()
         return self
@@ -231,9 +223,7 @@ class SecretSchema(NamedSchema, table=True):
         """
         metadata = None
         if include_metadata:
-            metadata = SecretResponseMetadata(
-                workspace=self.workspace.to_model(),
-            )
+            metadata = SecretResponseMetadata()
 
         # Don't load the secret values implicitly in the secret. The
         # SQL secret store will call `get_secret_values` to load the
@@ -242,7 +232,7 @@ class SecretSchema(NamedSchema, table=True):
             user=self.user.to_model() if self.user else None,
             created=self.created,
             updated=self.updated,
-            scope=SecretScope(self.scope),
+            private=self.private,
         )
         return SecretResponse(
             id=self.id,

zenml/zen_stores/schemas/service_connector_schemas.py

@@ -19,7 +19,7 @@ from datetime import datetime
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from uuid import UUID
 
-from sqlalchemy import TEXT, Column
+from sqlalchemy import TEXT, Column, UniqueConstraint
 from sqlmodel import Field, Relationship
 
 from zenml.models import (
@@ -33,7 +33,6 @@ from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.base_schemas import NamedSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 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.component_schemas import StackComponentSchema
@@ -43,6 +42,12 @@ class ServiceConnectorSchema(NamedSchema, table=True):
     """SQL Model for service connectors."""
 
     __tablename__ = "service_connector"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            name="unique_service_connector_name",
+        ),
+    )
 
     connector_type: str = Field(sa_column=Column(TEXT))
     description: str
@@ -57,18 +62,6 @@ class ServiceConnectorSchema(NamedSchema, table=True):
     expiration_seconds: Optional[int]
     labels: Optional[bytes]
 
-    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="service_connectors"
-    )
-
     user_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
         target=UserSchema.__tablename__,
@@ -146,7 +139,6 @@ class ServiceConnectorSchema(NamedSchema, table=True):
         """
         assert connector_request.user is not None, "User must be set."
         return cls(
-            workspace_id=connector_request.workspace,
             user_id=connector_request.user,
             name=connector_request.name,
             description=connector_request.description,
@@ -189,7 +181,7 @@ class ServiceConnectorSchema(NamedSchema, table=True):
         """
         for field, value in connector_update.model_dump(
             exclude_unset=False,
-            exclude={"workspace", "user", "secrets"},
+            exclude={"user", "secrets"},
         ).items():
             if value is None:
                 if field == "resource_id":
@@ -264,7 +256,6 @@ class ServiceConnectorSchema(NamedSchema, table=True):
         metadata = None
         if include_metadata:
             metadata = ServiceConnectorResponseMetadata(
-                workspace=self.workspace.to_model(),
                 configuration=json.loads(
                     base64.b64decode(self.configuration).decode()
                 )

zenml/zen_stores/schemas/service_schemas.py

@@ -35,9 +35,9 @@ from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.base_schemas import NamedSchema
 from zenml.zen_stores.schemas.model_schemas import ModelVersionSchema
 from zenml.zen_stores.schemas.pipeline_run_schemas import PipelineRunSchema
+from zenml.zen_stores.schemas.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 from zenml.zen_stores.schemas.user_schemas import UserSchema
-from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
 
 class ServiceSchema(NamedSchema, table=True):
@@ -45,15 +45,15 @@ class ServiceSchema(NamedSchema, table=True):
 
     __tablename__ = "service"
 
-    workspace_id: UUID = build_foreign_key_field(
+    project_id: UUID = build_foreign_key_field(
         source=__tablename__,
-        target=WorkspaceSchema.__tablename__,
-        source_column="workspace_id",
+        target=ProjectSchema.__tablename__,
+        source_column="project_id",
         target_column="id",
         ondelete="CASCADE",
         nullable=False,
     )
-    workspace: "WorkspaceSchema" = Relationship(back_populates="services")
+    project: "ProjectSchema" = Relationship(back_populates="services")
 
     user_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
@@ -135,7 +135,6 @@ class ServiceSchema(NamedSchema, table=True):
         """
         body = ServiceResponseBody(
             user=self.user.to_model() if self.user else None,
-            workspace=self.workspace.to_model(),
             created=self.created,
             updated=self.updated,
             service_type=json.loads(self.service_type),
@@ -147,7 +146,7 @@ class ServiceSchema(NamedSchema, table=True):
         metadata = None
         if include_metadata:
             metadata = ServiceResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 service_source=self.service_source,
                 config=json.loads(base64.b64decode(self.config).decode()),
                 status=json.loads(base64.b64decode(self.status).decode())
@@ -227,7 +226,7 @@ class ServiceSchema(NamedSchema, table=True):
         """
         return cls(
             name=service_request.name,
-            workspace_id=service_request.workspace,
+            project_id=service_request.project,
             user_id=service_request.user,
             service_source=service_request.service_source,
             service_type=service_request.service_type.model_dump_json(),

zenml/zen_stores/schemas/stack_schemas.py

@@ -18,7 +18,8 @@ import json
 from typing import TYPE_CHECKING, Any, List, Optional
 from uuid import UUID
 
-from sqlmodel import Relationship, SQLModel
+from sqlalchemy import UniqueConstraint
+from sqlmodel import Field, Relationship, SQLModel
 
 from zenml.models import (
     StackResponse,
@@ -30,7 +31,6 @@ from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.base_schemas import NamedSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 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.component_schemas import (
@@ -76,19 +76,17 @@ class StackSchema(NamedSchema, table=True):
     """SQL Model for stacks."""
 
     __tablename__ = "stack"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            name="unique_stack_name",
+        ),
+    )
+
+    description: Optional[str] = Field(default=None)
     stack_spec_path: Optional[str]
     labels: Optional[bytes]
 
-    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="stacks")
-
     user_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
         target=UserSchema.__tablename__,
@@ -123,7 +121,7 @@ class StackSchema(NamedSchema, table=True):
             The updated StackSchema.
         """
         for field, value in stack_update.model_dump(
-            exclude_unset=True, exclude={"workspace", "user"}
+            exclude_unset=True, exclude={"user"}
         ).items():
             if field == "components":
                 self.components = components
@@ -150,7 +148,6 @@ class StackSchema(NamedSchema, table=True):
             include_resources: Whether the resources will be filled.
             **kwargs: Keyword arguments to allow schema specific logic
 
-
         Returns:
             The converted model.
         """
@@ -162,12 +159,12 @@ class StackSchema(NamedSchema, table=True):
         metadata = None
         if include_metadata:
             metadata = StackResponseMetadata(
-                workspace=self.workspace.to_model(),
                 components={c.type: [c.to_model()] for c in self.components},
                 stack_spec_path=self.stack_spec_path,
                 labels=json.loads(base64.b64decode(self.labels).decode())
                 if self.labels
                 else None,
+                description=self.description,
             )
 
         return StackResponse(

zenml/zen_stores/schemas/step_run_schemas.py

@@ -50,10 +50,10 @@ from zenml.zen_stores.schemas.pipeline_deployment_schemas import (
     PipelineDeploymentSchema,
 )
 from zenml.zen_stores.schemas.pipeline_run_schemas import PipelineRunSchema
+from zenml.zen_stores.schemas.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 from zenml.zen_stores.schemas.user_schemas import UserSchema
 from zenml.zen_stores.schemas.utils import RunMetadataInterface
-from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
 if TYPE_CHECKING:
     from zenml.zen_stores.schemas.artifact_schemas import ArtifactVersionSchema
@@ -102,7 +102,7 @@ class StepRunSchema(NamedSchema, RunMetadataInterface, table=True):
         ondelete="SET NULL",
         nullable=True,
     )
-    deployment_id: UUID = build_foreign_key_field(
+    deployment_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
         target=PipelineDeploymentSchema.__tablename__,
         source_column="deployment_id",
@@ -126,15 +126,15 @@ class StepRunSchema(NamedSchema, RunMetadataInterface, table=True):
         ondelete="SET NULL",
         nullable=True,
     )
-    workspace_id: UUID = build_foreign_key_field(
+    project_id: UUID = build_foreign_key_field(
         source=__tablename__,
-        target=WorkspaceSchema.__tablename__,
-        source_column="workspace_id",
+        target=ProjectSchema.__tablename__,
+        source_column="project_id",
         target_column="id",
         ondelete="CASCADE",
         nullable=False,
     )
-    model_version_id: UUID = build_foreign_key_field(
+    model_version_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
         target=MODEL_VERSION_TABLENAME,
         source_column="model_version_id",
@@ -144,7 +144,7 @@ class StepRunSchema(NamedSchema, RunMetadataInterface, table=True):
     )
 
     # Relationships
-    workspace: "WorkspaceSchema" = Relationship(back_populates="step_runs")
+    project: "ProjectSchema" = Relationship(back_populates="step_runs")
     user: Optional["UserSchema"] = Relationship(back_populates="step_runs")
     deployment: Optional["PipelineDeploymentSchema"] = Relationship(
         back_populates="step_runs"
@@ -186,30 +186,32 @@ class StepRunSchema(NamedSchema, RunMetadataInterface, table=True):
     model_config = ConfigDict(protected_namespaces=())  # type: ignore[assignment]
 
     @classmethod
-    def from_request(cls, request: StepRunRequest) -> "StepRunSchema":
+    def from_request(
+        cls, request: StepRunRequest, deployment_id: Optional[UUID]
+    ) -> "StepRunSchema":
         """Create a step run schema from a step run request model.
 
         Args:
             request: The step run request model.
+            deployment_id: The deployment ID.
 
         Returns:
             The step run schema.
         """
         return cls(
             name=request.name,
-            workspace_id=request.workspace,
+            project_id=request.project,
             user_id=request.user,
             start_time=request.start_time,
             end_time=request.end_time,
             status=request.status.value,
+            deployment_id=deployment_id,
             original_step_run_id=request.original_step_run_id,
             pipeline_run_id=request.pipeline_run_id,
-            deployment_id=request.deployment,
             docstring=request.docstring,
             cache_key=request.cache_key,
             code_hash=request.code_hash,
             source_code=request.source_code,
-            model_version_id=request.model_version_id,
         )
 
     def to_model(
@@ -308,7 +310,7 @@ class StepRunSchema(NamedSchema, RunMetadataInterface, table=True):
         metadata = None
         if include_metadata:
             metadata = StepRunResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 config=full_step_config.config,
                 spec=full_step_config.spec,
                 cache_key=self.cache_key,
@@ -355,9 +357,6 @@ class StepRunSchema(NamedSchema, RunMetadataInterface, table=True):
                 self.status = value.value
             if key == "end_time":
                 self.end_time = value
-            if key == "model_version_id":
-                if value and self.model_version_id is None:
-                    self.model_version_id = value
 
         self.updated = utc_now()
 

zenml/zen_stores/schemas/tag_schemas.py

@@ -13,10 +13,10 @@
 #  permissions and limitations under the License.
 """SQLModel implementation of tag tables."""
 
-from typing import Any, List
+from typing import Any, List, Optional
 from uuid import UUID
 
-from sqlalchemy import VARCHAR, Column
+from sqlalchemy import VARCHAR, Column, UniqueConstraint
 from sqlmodel import Field, Relationship
 
 from zenml.enums import ColorVariants, TaggableResourceTypes
@@ -27,6 +27,7 @@ from zenml.models import (
     TagResourceResponseBody,
     TagResponse,
     TagResponseBody,
+    TagResponseMetadata,
     TagUpdate,
 )
 from zenml.utils.time_utils import utc_now
@@ -35,14 +36,33 @@ from zenml.zen_stores.schemas.schema_utils import (
     build_foreign_key_field,
     build_index,
 )
+from zenml.zen_stores.schemas.user_schemas import UserSchema
 
 
 class TagSchema(NamedSchema, table=True):
     """SQL Model for tag."""
 
     __tablename__ = "tag"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            name="unique_tag_name",
+        ),
+    )
+
+    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="tags")
 
     color: str = Field(sa_column=Column(VARCHAR(255), nullable=False))
+    exclusive: bool = Field(default=False)
+
     links: List["TagResourceSchema"] = Relationship(
         back_populates="tag",
         sa_relationship_kwargs={"overlaps": "tags", "cascade": "delete"},
@@ -60,7 +80,9 @@ class TagSchema(NamedSchema, table=True):
         """
         return cls(
             name=request.name,
+            exclusive=request.exclusive,
             color=request.color.value,
+            user_id=request.user,
         )
 
     def to_model(
@@ -80,15 +102,21 @@ class TagSchema(NamedSchema, table=True):
         Returns:
             The created `TagResponse`.
         """
+        metadata = None
+        if include_metadata:
+            metadata = TagResponseMetadata()
         return TagResponse(
             id=self.id,
             name=self.name,
             body=TagResponseBody(
+                user=self.user.to_model() if self.user else None,
                 created=self.created,
                 updated=self.updated,
                 color=ColorVariants(self.color),
+                exclusive=self.exclusive,
                 tagged_count=len(self.links),
             ),
+            metadata=metadata,
         )
 
     def update(self, update: TagUpdate) -> "TagSchema":

zenml/zen_stores/schemas/trigger_schemas.py

@@ -18,7 +18,7 @@ import json
 from typing import Any, List, Optional, cast
 from uuid import UUID
 
-from sqlalchemy import TEXT, Column
+from sqlalchemy import TEXT, Column, UniqueConstraint
 from sqlmodel import Field, Relationship
 
 from zenml.config.schedule import Schedule
@@ -41,26 +41,33 @@ from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.action_schemas import ActionSchema
 from zenml.zen_stores.schemas.base_schemas import BaseSchema, NamedSchema
 from zenml.zen_stores.schemas.event_source_schemas import EventSourceSchema
+from zenml.zen_stores.schemas.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 from zenml.zen_stores.schemas.user_schemas import UserSchema
 from zenml.zen_stores.schemas.utils import get_page_from_list
-from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
 
 class TriggerSchema(NamedSchema, table=True):
     """SQL Model for triggers."""
 
     __tablename__ = "trigger"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            "project_id",
+            name="unique_trigger_name_in_project",
+        ),
+    )
 
-    workspace_id: UUID = build_foreign_key_field(
+    project_id: UUID = build_foreign_key_field(
         source=__tablename__,
-        target=WorkspaceSchema.__tablename__,
-        source_column="workspace_id",
+        target=ProjectSchema.__tablename__,
+        source_column="project_id",
         target_column="id",
         ondelete="CASCADE",
         nullable=False,
     )
-    workspace: "WorkspaceSchema" = Relationship(back_populates="triggers")
+    project: "ProjectSchema" = Relationship(back_populates="triggers")
 
     user_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
@@ -148,7 +155,7 @@ class TriggerSchema(NamedSchema, table=True):
         """
         return cls(
             name=request.name,
-            workspace_id=request.workspace,
+            project_id=request.project,
             user_id=request.user,
             action_id=request.action_id,
             event_source_id=request.event_source_id,
@@ -201,7 +208,7 @@ class TriggerSchema(NamedSchema, table=True):
         metadata = None
         if include_metadata:
             metadata = TriggerResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 event_filter=json.loads(
                     base64.b64decode(self.event_filter).decode()
                 ),