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

zenml/zen_stores/schemas/pipeline_build_schemas.py

@@ -31,10 +31,10 @@ from zenml.models import (
 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.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 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
 
 
 class PipelineBuildSchema(BaseSchema, table=True):
@@ -52,15 +52,15 @@ class PipelineBuildSchema(BaseSchema, table=True):
     )
     user: Optional["UserSchema"] = Relationship(back_populates="builds")
 
-    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="builds")
+    project: "ProjectSchema" = Relationship(back_populates="builds")
 
     stack_id: Optional[UUID] = build_foreign_key_field(
         source=__tablename__,
@@ -117,7 +117,7 @@ class PipelineBuildSchema(BaseSchema, table=True):
         """
         return cls(
             stack_id=request.stack,
-            workspace_id=request.workspace,
+            project_id=request.project,
             user_id=request.user,
             pipeline_id=request.pipeline,
             images=json.dumps(request.images, default=pydantic_encoder),
@@ -155,7 +155,7 @@ class PipelineBuildSchema(BaseSchema, table=True):
         metadata = None
         if include_metadata:
             metadata = PipelineBuildResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 pipeline=self.pipeline.to_model() if self.pipeline else None,
                 stack=self.stack.to_model() if self.stack else None,
                 images=json.loads(self.images),

zenml/zen_stores/schemas/pipeline_deployment_schemas.py

@@ -38,11 +38,11 @@ from zenml.zen_stores.schemas.code_repository_schemas import (
 )
 from zenml.zen_stores.schemas.pipeline_build_schemas import PipelineBuildSchema
 from zenml.zen_stores.schemas.pipeline_schemas import PipelineSchema
+from zenml.zen_stores.schemas.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schedule_schema import ScheduleSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 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_run_schemas import PipelineRunSchema
@@ -95,10 +95,10 @@ class PipelineDeploymentSchema(BaseSchema, 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,
@@ -148,8 +148,10 @@ class PipelineDeploymentSchema(BaseSchema, table=True):
     template_id: Optional[UUID] = None
 
     # SQLModel Relationships
-    user: Optional["UserSchema"] = Relationship()
-    workspace: "WorkspaceSchema" = Relationship()
+    user: Optional["UserSchema"] = Relationship(
+        back_populates="deployments",
+    )
+    project: "ProjectSchema" = Relationship()
     stack: Optional["StackSchema"] = Relationship()
     pipeline: Optional["PipelineSchema"] = Relationship()
     schedule: Optional["ScheduleSchema"] = Relationship()
@@ -185,7 +187,7 @@ class PipelineDeploymentSchema(BaseSchema, table=True):
         """
         return cls(
             stack_id=request.stack,
-            workspace_id=request.workspace,
+            project_id=request.project,
             pipeline_id=request.pipeline,
             build_id=request.build,
             user_id=request.user,
@@ -243,7 +245,7 @@ class PipelineDeploymentSchema(BaseSchema, table=True):
                 step_configurations[s] = Step.model_validate(c)
 
             metadata = PipelineDeploymentResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 run_name_template=self.run_name_template,
                 pipeline_configuration=pipeline_configuration,
                 step_configurations=step_configurations,

zenml/zen_stores/schemas/pipeline_run_schemas.py

@@ -45,13 +45,13 @@ from zenml.zen_stores.schemas.pipeline_deployment_schemas import (
     PipelineDeploymentSchema,
 )
 from zenml.zen_stores.schemas.pipeline_schemas import PipelineSchema
+from zenml.zen_stores.schemas.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schedule_schema import ScheduleSchema
 from zenml.zen_stores.schemas.schema_utils import build_foreign_key_field
 from zenml.zen_stores.schemas.stack_schemas import StackSchema
 from zenml.zen_stores.schemas.trigger_schemas import TriggerExecutionSchema
 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.logs_schemas import LogsSchema
@@ -77,8 +77,8 @@ class PipelineRunSchema(NamedSchema, RunMetadataInterface, table=True):
         ),
         UniqueConstraint(
             "name",
-            "workspace_id",
-            name="unique_run_name_in_workspace",
+            "project_id",
+            name="unique_run_name_in_project",
         ),
     )
 
@@ -108,10 +108,10 @@ class PipelineRunSchema(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,
@@ -137,7 +137,7 @@ class PipelineRunSchema(NamedSchema, RunMetadataInterface, table=True):
     deployment: Optional["PipelineDeploymentSchema"] = Relationship(
         back_populates="pipeline_runs"
     )
-    workspace: "WorkspaceSchema" = Relationship(back_populates="runs")
+    project: "ProjectSchema" = Relationship(back_populates="runs")
     user: Optional["UserSchema"] = Relationship(back_populates="runs")
     run_metadata: List["RunMetadataSchema"] = Relationship(
         sa_relationship_kwargs=dict(
@@ -241,7 +241,7 @@ class PipelineRunSchema(NamedSchema, RunMetadataInterface, table=True):
         orchestrator_environment = json.dumps(request.orchestrator_environment)
 
         return cls(
-            workspace_id=request.workspace,
+            project_id=request.project,
             user_id=request.user,
             name=request.name,
             orchestrator_run_id=request.orchestrator_run_id,
@@ -251,7 +251,6 @@ class PipelineRunSchema(NamedSchema, RunMetadataInterface, table=True):
             pipeline_id=request.pipeline,
             deployment_id=request.deployment,
             trigger_execution_id=request.trigger_execution_id,
-            model_version_id=request.model_version_id,
         )
 
     def fetch_metadata_collection(self) -> Dict[str, List[RunMetadataEntry]]:
@@ -385,7 +384,7 @@ class PipelineRunSchema(NamedSchema, RunMetadataInterface, table=True):
                 else {}
             )
             metadata = PipelineRunResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 run_metadata=self.fetch_metadata(),
                 config=config,
                 steps=steps,
@@ -435,8 +434,6 @@ class PipelineRunSchema(NamedSchema, RunMetadataInterface, table=True):
         if run_update.status:
             self.status = run_update.status.value
             self.end_time = run_update.end_time
-        if run_update.model_version_id and self.model_version_id is None:
-            self.model_version_id = run_update.model_version_id
 
         self.updated = utc_now()
         return self

zenml/zen_stores/schemas/pipeline_schemas.py

@@ -31,9 +31,9 @@ from zenml.models import (
 )
 from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.base_schemas import NamedSchema
+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
 
 if TYPE_CHECKING:
     from zenml.zen_stores.schemas.pipeline_build_schemas import (
@@ -54,18 +54,18 @@ class PipelineSchema(NamedSchema, table=True):
     __table_args__ = (
         UniqueConstraint(
             "name",
-            "workspace_id",
-            name="unique_pipeline_name_in_workspace",
+            "project_id",
+            name="unique_pipeline_name_in_project",
         ),
     )
     # Fields
     description: Optional[str] = Field(sa_column=Column(TEXT, nullable=True))
 
     # Foreign keys
-    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,
@@ -81,7 +81,7 @@ class PipelineSchema(NamedSchema, table=True):
 
     # Relationships
     user: Optional["UserSchema"] = Relationship(back_populates="pipelines")
-    workspace: "WorkspaceSchema" = Relationship(back_populates="pipelines")
+    project: "ProjectSchema" = Relationship(back_populates="pipelines")
 
     schedules: List["ScheduleSchema"] = Relationship(
         back_populates="pipeline",
@@ -146,7 +146,7 @@ class PipelineSchema(NamedSchema, table=True):
         return cls(
             name=pipeline_request.name,
             description=pipeline_request.description,
-            workspace_id=pipeline_request.workspace,
+            project_id=pipeline_request.project,
             user_id=pipeline_request.user,
         )
 
@@ -179,7 +179,7 @@ class PipelineSchema(NamedSchema, table=True):
         metadata = None
         if include_metadata:
             metadata = PipelineResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 description=self.description,
             )
 

zenml/zen_stores/schemas/{workspace_schemas.py → project_schemas.py}

@@ -11,18 +11,19 @@
 #  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.
-"""SQL Model Implementations for Workspaces."""
+"""SQL Model Implementations for projects."""
 
 from typing import TYPE_CHECKING, Any, List
 
+from sqlalchemy import UniqueConstraint
 from sqlmodel import Relationship
 
 from zenml.models import (
-    WorkspaceRequest,
-    WorkspaceResponse,
-    WorkspaceResponseBody,
-    WorkspaceResponseMetadata,
-    WorkspaceUpdate,
+    ProjectRequest,
+    ProjectResponse,
+    ProjectResponseBody,
+    ProjectResponseMetadata,
+    ProjectUpdate,
 )
 from zenml.utils.time_utils import utc_now
 from zenml.zen_stores.schemas.base_schemas import NamedSchema
@@ -33,7 +34,6 @@ if TYPE_CHECKING:
         ArtifactVersionSchema,
         CodeRepositorySchema,
         EventSourceSchema,
-        FlavorSchema,
         ModelSchema,
         ModelVersionSchema,
         PipelineBuildSchema,
@@ -42,128 +42,115 @@ if TYPE_CHECKING:
         PipelineSchema,
         RunMetadataSchema,
         ScheduleSchema,
-        SecretSchema,
-        ServiceConnectorSchema,
         ServiceSchema,
-        StackComponentSchema,
-        StackSchema,
         StepRunSchema,
         TriggerSchema,
     )
 
 
-class WorkspaceSchema(NamedSchema, table=True):
-    """SQL Model for workspaces."""
+class ProjectSchema(NamedSchema, table=True):
+    """SQL Model for projects."""
 
-    __tablename__ = "workspace"
+    __tablename__ = "project"
+    __table_args__ = (
+        UniqueConstraint(
+            "name",
+            name="unique_project_name",
+        ),
+    )
 
+    display_name: str
     description: str
 
-    stacks: List["StackSchema"] = Relationship(
-        back_populates="workspace",
-        sa_relationship_kwargs={"cascade": "delete"},
-    )
-    components: List["StackComponentSchema"] = Relationship(
-        back_populates="workspace",
-        sa_relationship_kwargs={"cascade": "delete"},
-    )
-    flavors: List["FlavorSchema"] = Relationship(
-        back_populates="workspace",
-        sa_relationship_kwargs={"cascade": "delete"},
-    )
     pipelines: List["PipelineSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     schedules: List["ScheduleSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     runs: List["PipelineRunSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     step_runs: List["StepRunSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     builds: List["PipelineBuildSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     artifact_versions: List["ArtifactVersionSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     run_metadata: List["RunMetadataSchema"] = Relationship(
-        back_populates="workspace",
-        sa_relationship_kwargs={"cascade": "delete"},
-    )
-    secrets: List["SecretSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     actions: List["ActionSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     triggers: List["TriggerSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     event_sources: List["EventSourceSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
 
     deployments: List["PipelineDeploymentSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     code_repositories: List["CodeRepositorySchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     services: List["ServiceSchema"] = Relationship(
-        back_populates="workspace",
-        sa_relationship_kwargs={"cascade": "delete"},
-    )
-    service_connectors: List["ServiceConnectorSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     models: List["ModelSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
     model_versions: List["ModelVersionSchema"] = Relationship(
-        back_populates="workspace",
+        back_populates="project",
         sa_relationship_kwargs={"cascade": "delete"},
     )
 
     @classmethod
-    def from_request(cls, workspace: WorkspaceRequest) -> "WorkspaceSchema":
-        """Create a `WorkspaceSchema` from a `WorkspaceResponse`.
+    def from_request(cls, project: ProjectRequest) -> "ProjectSchema":
+        """Create a `ProjectSchema` from a `ProjectResponse`.
 
         Args:
-            workspace: The `WorkspaceResponse` from which to create the schema.
+            project: The `ProjectResponse` from which to create the schema.
 
         Returns:
-            The created `WorkspaceSchema`.
+            The created `ProjectSchema`.
         """
-        return cls(name=workspace.name, description=workspace.description)
+        return cls(
+            name=project.name,
+            description=project.description,
+            display_name=project.display_name,
+        )
 
-    def update(self, workspace_update: WorkspaceUpdate) -> "WorkspaceSchema":
-        """Update a `WorkspaceSchema` from a `WorkspaceUpdate`.
+    def update(self, project_update: ProjectUpdate) -> "ProjectSchema":
+        """Update a `ProjectSchema` from a `ProjectUpdate`.
 
         Args:
-            workspace_update: The `WorkspaceUpdate` from which to update the
+            project_update: The `ProjectUpdate` from which to update the
                 schema.
 
         Returns:
-            The updated `WorkspaceSchema`.
+            The updated `ProjectSchema`.
         """
-        for field, value in workspace_update.model_dump(
+        for field, value in project_update.model_dump(
             exclude_unset=True
         ).items():
             setattr(self, field, value)
@@ -176,8 +163,8 @@ class WorkspaceSchema(NamedSchema, table=True):
         include_metadata: bool = False,
         include_resources: bool = False,
         **kwargs: Any,
-    ) -> WorkspaceResponse:
-        """Convert a `WorkspaceSchema` to a `WorkspaceResponse`.
+    ) -> ProjectResponse:
+        """Convert a `ProjectSchema` to a `ProjectResponse`.
 
         Args:
             include_metadata: Whether the metadata will be filled.
@@ -186,17 +173,18 @@ class WorkspaceSchema(NamedSchema, table=True):
 
 
         Returns:
-            The converted `WorkspaceResponseModel`.
+            The converted `ProjectResponseModel`.
         """
         metadata = None
         if include_metadata:
-            metadata = WorkspaceResponseMetadata(
+            metadata = ProjectResponseMetadata(
                 description=self.description,
             )
-        return WorkspaceResponse(
+        return ProjectResponse(
             id=self.id,
             name=self.name,
-            body=WorkspaceResponseBody(
+            body=ProjectResponseBody(
+                display_name=self.display_name,
                 created=self.created,
                 updated=self.updated,
             ),

zenml/zen_stores/schemas/run_metadata_schemas.py

@@ -21,13 +21,13 @@ from sqlmodel import Field, Relationship, SQLModel
 
 from zenml.zen_stores.schemas.base_schemas import BaseSchema
 from zenml.zen_stores.schemas.component_schemas import StackComponentSchema
+from zenml.zen_stores.schemas.project_schemas import ProjectSchema
 from zenml.zen_stores.schemas.schema_utils import (
     build_foreign_key_field,
     build_index,
 )
 from zenml.zen_stores.schemas.step_run_schemas import StepRunSchema
 from zenml.zen_stores.schemas.user_schemas import UserSchema
-from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
 
 
 class RunMetadataSchema(BaseSchema, table=True):
@@ -57,15 +57,15 @@ class RunMetadataSchema(BaseSchema, table=True):
     )
     user: Optional["UserSchema"] = Relationship(back_populates="run_metadata")
 
-    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="run_metadata")
+    project: "ProjectSchema" = Relationship(back_populates="run_metadata")
 
     key: str
     value: str = Field(sa_column=Column(TEXT, nullable=False))

zenml/zen_stores/schemas/run_template_schemas.py

@@ -32,10 +32,10 @@ from zenml.models import (
     RunTemplateUpdate,
 )
 from zenml.utils.time_utils import utc_now
-from zenml.zen_stores.schemas.base_schemas import BaseSchema
+from zenml.zen_stores.schemas.base_schemas import NamedSchema
+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
 
 if TYPE_CHECKING:
     from zenml.zen_stores.schemas.pipeline_deployment_schemas import (
@@ -45,19 +45,18 @@ if TYPE_CHECKING:
     from zenml.zen_stores.schemas.tag_schemas import TagSchema
 
 
-class RunTemplateSchema(BaseSchema, table=True):
+class RunTemplateSchema(NamedSchema, table=True):
     """SQL Model for run templates."""
 
     __tablename__ = "run_template"
     __table_args__ = (
         UniqueConstraint(
             "name",
-            "workspace_id",
-            name="unique_template_name_in_workspace",
+            "project_id",
+            name="unique_template_name_in_project",
         ),
     )
 
-    name: str = Field(nullable=False)
     description: Optional[str] = Field(
         sa_column=Column(
             String(length=MEDIUMTEXT_MAX_LENGTH).with_variant(
@@ -75,10 +74,10 @@ class RunTemplateSchema(BaseSchema, 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,
@@ -92,8 +91,10 @@ class RunTemplateSchema(BaseSchema, table=True):
         nullable=True,
     )
 
-    user: Optional["UserSchema"] = Relationship()
-    workspace: "WorkspaceSchema" = Relationship()
+    user: Optional["UserSchema"] = Relationship(
+        back_populates="run_templates",
+    )
+    project: "ProjectSchema" = Relationship()
     source_deployment: Optional["PipelineDeploymentSchema"] = Relationship(
         sa_relationship_kwargs={
             "foreign_keys": "RunTemplateSchema.source_deployment_id",
@@ -162,7 +163,7 @@ class RunTemplateSchema(BaseSchema, table=True):
         """
         return cls(
             user_id=request.user,
-            workspace_id=request.workspace,
+            project_id=request.project,
             name=request.name,
             description=request.description,
             source_deployment_id=request.source_deployment_id,
@@ -180,6 +181,9 @@ class RunTemplateSchema(BaseSchema, table=True):
         for field, value in update.model_dump(
             exclude_unset=True, exclude_none=True
         ).items():
+            if field in ["add_tags", "remove_tags"]:
+                # Tags are handled separately
+                continue
             setattr(self, field, value)
 
         self.updated = utc_now()
@@ -246,7 +250,7 @@ class RunTemplateSchema(BaseSchema, table=True):
                     )
 
             metadata = RunTemplateResponseMetadata(
-                workspace=self.workspace.to_model(),
+                project=self.project.to_model(),
                 description=self.description,
                 pipeline_spec=pipeline_spec,
                 config_template=config_template,