zenml-nightly 0.70.0.dev20241125__py3-none-any.whl → 0.70.0.dev20241201__py3-none-any.whl

zenml/zen_server/rbac/utils.py

@@ -413,8 +413,6 @@ def get_resource_type_for_model(
         TagResponse,
         TriggerExecutionResponse,
         TriggerResponse,
-        UserResponse,
-        WorkspaceResponse,
     )
 
     mapping: Dict[
@@ -434,8 +432,8 @@ def get_resource_type_for_model(
         ModelVersionResponse: ResourceType.MODEL_VERSION,
         ArtifactResponse: ResourceType.ARTIFACT,
         ArtifactVersionResponse: ResourceType.ARTIFACT_VERSION,
-        WorkspaceResponse: ResourceType.WORKSPACE,
-        UserResponse: ResourceType.USER,
+        # WorkspaceResponse: ResourceType.WORKSPACE,
+        # UserResponse: ResourceType.USER,
         PipelineDeploymentResponse: ResourceType.PIPELINE_DEPLOYMENT,
         PipelineBuildResponse: ResourceType.PIPELINE_BUILD,
         PipelineRunResponse: ResourceType.PIPELINE_RUN,
@@ -570,7 +568,6 @@ def get_schema_for_resource_type(
         TriggerExecutionSchema,
         TriggerSchema,
         UserSchema,
-        WorkspaceSchema,
     )
 
     mapping: Dict[ResourceType, Type["BaseSchema"]] = {
@@ -588,13 +585,13 @@ def get_schema_for_resource_type(
         ResourceType.SERVICE: ServiceSchema,
         ResourceType.TAG: TagSchema,
         ResourceType.SERVICE_ACCOUNT: UserSchema,
-        ResourceType.WORKSPACE: WorkspaceSchema,
+        # ResourceType.WORKSPACE: WorkspaceSchema,
         ResourceType.PIPELINE_RUN: PipelineRunSchema,
         ResourceType.PIPELINE_DEPLOYMENT: PipelineDeploymentSchema,
         ResourceType.PIPELINE_BUILD: PipelineBuildSchema,
         ResourceType.RUN_TEMPLATE: RunTemplateSchema,
         ResourceType.RUN_METADATA: RunMetadataSchema,
-        ResourceType.USER: UserSchema,
+        # ResourceType.USER: UserSchema,
         ResourceType.ACTION: ActionSchema,
         ResourceType.EVENT_SOURCE: EventSourceSchema,
         ResourceType.TRIGGER: TriggerSchema,

zenml/zen_server/routers/users_endpoints.py

@@ -46,14 +46,10 @@ from zenml.zen_server.auth import (
 )
 from zenml.zen_server.exceptions import error_response
 from zenml.zen_server.rate_limit import RequestLimiter
-from zenml.zen_server.rbac.endpoint_utils import (
-    verify_permissions_and_create_entity,
-)
 from zenml.zen_server.rbac.models import Action, Resource, ResourceType
 from zenml.zen_server.rbac.utils import (
     dehydrate_page,
     dehydrate_response_model,
-    get_allowed_resource_ids,
     get_schema_for_resource_type,
     update_resource_membership,
     verify_permission_for_model,
@@ -112,17 +108,18 @@ def list_users(
     Returns:
         A list of all users.
     """
-    allowed_ids = get_allowed_resource_ids(resource_type=ResourceType.USER)
-    if allowed_ids is not None:
-        # Make sure users can see themselves
-        allowed_ids.add(auth_context.user.id)
-    else:
-        if not auth_context.user.is_admin and not server_config().rbac_enabled:
-            allowed_ids = {auth_context.user.id}
-
-    user_filter_model.configure_rbac(
-        authenticated_user_id=auth_context.user.id, id=allowed_ids
-    )
+    # allowed_ids = get_allowed_resource_ids(resource_type=ResourceType.USER)
+    # if allowed_ids is not None:
+    #     # Make sure users can see themselves
+    #     allowed_ids.add(auth_context.user.id)
+    # else:
+    #     if not auth_context.user.is_admin and not server_config().rbac_enabled:
+    #         allowed_ids = {auth_context.user.id}
+    if not auth_context.user.is_admin and not server_config().rbac_enabled:
+        user_filter_model.configure_rbac(
+            authenticated_user_id=auth_context.user.id,
+            id={auth_context.user.id},
+        )
 
     page = zen_store().list_users(
         user_filter_model=user_filter_model, hydrate=hydrate
@@ -175,11 +172,12 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
             auth_context.user.is_admin, "create user"
         )
 
-        new_user = verify_permissions_and_create_entity(
-            request_model=user,
-            resource_type=ResourceType.USER,
-            create_method=zen_store().create_user,
-        )
+        # new_user = verify_permissions_and_create_entity(
+        #     request_model=user,
+        #     resource_type=ResourceType.USER,
+        #     create_method=zen_store().create_user,
+        # )
+        new_user = zen_store().create_user(user)
 
         # add back the original unhashed activation token, if generated, to
         # send it back to the client
@@ -217,10 +215,10 @@ def get_user(
         verify_admin_status_if_no_rbac(
             auth_context.user.is_admin, "get other user"
         )
-        verify_permission_for_model(
-            user,
-            action=Action.READ,
-        )
+        # verify_permission_for_model(
+        #     user,
+        #     action=Action.READ,
+        # )
 
     return dehydrate_response_model(user)
 
@@ -304,10 +302,10 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
             verify_admin_status_if_no_rbac(
                 auth_context.user.is_admin, "update other user account"
             )
-            verify_permission_for_model(
-                user,
-                action=Action.UPDATE,
-            )
+            # verify_permission_for_model(
+            #     user,
+            #     action=Action.UPDATE,
+            # )
 
         # Validate a password change
         if user_update.password is not None:
@@ -497,10 +495,10 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
         verify_admin_status_if_no_rbac(
             auth_context.user.is_admin, "deactivate user"
         )
-        verify_permission_for_model(
-            user,
-            action=Action.UPDATE,
-        )
+        # verify_permission_for_model(
+        #     user,
+        #     action=Action.UPDATE,
+        # )
 
         user_update = UserUpdate(
             active=False,
@@ -548,10 +546,10 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
             verify_admin_status_if_no_rbac(
                 auth_context.user.is_admin, "delete user"
             )
-            verify_permission_for_model(
-                user,
-                action=Action.DELETE,
-            )
+            # verify_permission_for_model(
+            #     user,
+            #     action=Action.DELETE,
+            # )
 
         zen_store().delete_user(user_name_or_id=user_name_or_id)
 
@@ -746,7 +744,7 @@ if server_config().rbac_enabled:
             KeyError: If no resource with the given type and ID exists.
         """
         user = zen_store().get_user(user_name_or_id)
-        verify_permission_for_model(user, action=Action.READ)
+        # verify_permission_for_model(user, action=Action.READ)
 
         if user.id == auth_context.user.id:
             raise ValueError(

zenml/zen_server/routers/workspaces_endpoints.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Endpoint definitions for workspaces."""
 
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, Security
@@ -98,13 +98,13 @@ from zenml.zen_server.feature_gate.endpoint_utils import (
 )
 from zenml.zen_server.rbac.endpoint_utils import (
     verify_permissions_and_create_entity,
-    verify_permissions_and_delete_entity,
-    verify_permissions_and_get_entity,
     verify_permissions_and_list_entities,
-    verify_permissions_and_update_entity,
 )
 from zenml.zen_server.rbac.models import Action, ResourceType
 from zenml.zen_server.rbac.utils import (
+    batch_verify_permissions_for_models,
+    dehydrate_page,
+    dehydrate_response_model,
     get_allowed_resource_ids,
     verify_permission,
     verify_permission_for_model,
@@ -146,12 +146,10 @@ def list_workspaces(
     Returns:
         A list of workspaces.
     """
-    return verify_permissions_and_list_entities(
-        filter_model=workspace_filter_model,
-        resource_type=ResourceType.WORKSPACE,
-        list_method=zen_store().list_workspaces,
-        hydrate=hydrate,
+    workspaces = zen_store().list_workspaces(
+        workspace_filter_model, hydrate=hydrate
     )
+    return dehydrate_page(workspaces)
 
 
 @router.post(
@@ -160,7 +158,7 @@ def list_workspaces(
 )
 @handle_exceptions
 def create_workspace(
-    workspace: WorkspaceRequest,
+    workspace_request: WorkspaceRequest,
     _: AuthContext = Security(authorize),
 ) -> WorkspaceResponse:
     """Creates a workspace based on the requestBody.
@@ -168,16 +166,13 @@ def create_workspace(
     # noqa: DAR401
 
     Args:
-        workspace: Workspace to create.
+        workspace_request: Workspace to create.
 
     Returns:
         The created workspace.
     """
-    return verify_permissions_and_create_entity(
-        request_model=workspace,
-        resource_type=ResourceType.WORKSPACE,
-        create_method=zen_store().create_workspace,
-    )
+    workspace = zen_store().create_workspace(workspace_request)
+    return dehydrate_response_model(workspace)
 
 
 @router.get(
@@ -203,11 +198,10 @@ def get_workspace(
     Returns:
         The requested workspace.
     """
-    return verify_permissions_and_get_entity(
-        id=workspace_name_or_id,
-        get_method=zen_store().get_workspace,
-        hydrate=hydrate,
+    workspace = zen_store().get_workspace(
+        workspace_name_or_id, hydrate=hydrate
     )
+    return dehydrate_response_model(workspace)
 
 
 @router.put(
@@ -231,12 +225,11 @@ def update_workspace(
     Returns:
         The updated workspace.
     """
-    return verify_permissions_and_update_entity(
-        id=workspace_name_or_id,
-        update_model=workspace_update,
-        get_method=zen_store().get_workspace,
-        update_method=zen_store().update_workspace,
+    workspace = zen_store().get_workspace(workspace_name_or_id, hydrate=False)
+    updated_workspace = zen_store().update_workspace(
+        workspace_id=workspace.id, workspace_update=workspace_update
     )
+    return dehydrate_response_model(updated_workspace)
 
 
 @router.delete(
@@ -253,11 +246,7 @@ def delete_workspace(
     Args:
         workspace_name_or_id: Name or ID of the workspace.
     """
-    verify_permissions_and_delete_entity(
-        id=workspace_name_or_id,
-        get_method=zen_store().get_workspace,
-        delete_method=zen_store().delete_workspace,
-    )
+    zen_store().delete_workspace(workspace_name_or_id)
 
 
 @router.get(
@@ -951,20 +940,21 @@ def get_or_create_pipeline_run(
             "is not supported."
         )
 
-    verify_permission(
-        resource_type=ResourceType.PIPELINE_RUN, action=Action.CREATE
-    )
+    def _pre_creation_hook() -> None:
+        verify_permission(
+            resource_type=ResourceType.PIPELINE_RUN, action=Action.CREATE
+        )
+        check_entitlement(resource_type=ResourceType.PIPELINE_RUN)
 
     run, created = zen_store().get_or_create_run(
-        pipeline_run=pipeline_run,
-        pre_creation_hook=lambda: check_entitlement(
-            resource_type=ResourceType.PIPELINE_RUN
-        ),
+        pipeline_run=pipeline_run, pre_creation_hook=_pre_creation_hook
     )
     if created:
         report_usage(
             resource_type=ResourceType.PIPELINE_RUN, resource_id=run.id
         )
+    else:
+        verify_permission_for_model(run, action=Action.READ)
 
     return run, created
 
@@ -1009,24 +999,23 @@ def create_run_metadata(
             "is not supported."
         )
 
-    if run_metadata.resource_type == MetadataResourceTypes.PIPELINE_RUN:
-        run = zen_store().get_run(run_metadata.resource_id)
-        verify_permission_for_model(run, action=Action.UPDATE)
-    elif run_metadata.resource_type == MetadataResourceTypes.STEP_RUN:
-        step = zen_store().get_run_step(run_metadata.resource_id)
-        verify_permission_for_model(step, action=Action.UPDATE)
-    elif run_metadata.resource_type == MetadataResourceTypes.ARTIFACT_VERSION:
-        artifact_version = zen_store().get_artifact_version(
-            run_metadata.resource_id
-        )
-        verify_permission_for_model(artifact_version, action=Action.UPDATE)
-    elif run_metadata.resource_type == MetadataResourceTypes.MODEL_VERSION:
-        model_version = zen_store().get_model_version(run_metadata.resource_id)
-        verify_permission_for_model(model_version, action=Action.UPDATE)
-    else:
-        raise RuntimeError(
-            f"Unknown resource type: {run_metadata.resource_type}"
-        )
+    verify_models: List[Any] = []
+    for resource in run_metadata.resources:
+        if resource.type == MetadataResourceTypes.PIPELINE_RUN:
+            verify_models.append(zen_store().get_run(resource.id))
+        elif resource.type == MetadataResourceTypes.STEP_RUN:
+            verify_models.append(zen_store().get_run_step(resource.id))
+        elif resource.type == MetadataResourceTypes.ARTIFACT_VERSION:
+            verify_models.append(zen_store().get_artifact_version(resource.id))
+        elif resource.type == MetadataResourceTypes.MODEL_VERSION:
+            verify_models.append(zen_store().get_model_version(resource.id))
+        else:
+            raise RuntimeError(f"Unknown resource type: {resource.type}")
+
+    batch_verify_permissions_for_models(
+        models=verify_models,
+        action=Action.UPDATE,
+    )
 
     verify_permission(
         resource_type=ResourceType.RUN_METADATA, action=Action.CREATE

zenml/zen_server/template_execution/utils.py

@@ -363,6 +363,7 @@ def deployment_request_from_template(
                     "external_input_artifacts",
                     "model_artifacts_or_metadata",
                     "client_lazy_loaders",
+                    "substitutions",
                     "outputs",
                 }
             ),

zenml/zen_stores/migrations/versions/b73bc71f1106_remove_component_spec_path.py

@@ -0,0 +1,36 @@
+"""Remove component spec path [b73bc71f1106].
+
+Revision ID: b73bc71f1106
+Revises: ec6307720f92
+Create Date: 2024-11-29 09:36:33.089945
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "b73bc71f1106"
+down_revision = "ec6307720f92"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    """Upgrade database schema and/or data, creating a new revision."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("stack_component", schema=None) as batch_op:
+        batch_op.drop_column("component_spec_path")
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade database schema and/or data back to the previous revision."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("stack_component", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column("component_spec_path", sa.VARCHAR(), nullable=True)
+        )
+
+    # ### end Alembic commands ###

zenml/zen_stores/migrations/versions/cc269488e5a9_separate_run_metadata.py

@@ -0,0 +1,135 @@
+"""Separate run metadata into resource link table with new UUIDs.
+
+Revision ID: cc269488e5a9
+Revises: b73bc71f1106
+Create Date: 2024-11-12 09:46:46.587478
+"""
+
+import uuid
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "cc269488e5a9"
+down_revision = "b73bc71f1106"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    """Creates the 'run_metadata_resource' table and migrates data."""
+    op.create_table(
+        "run_metadata_resource",
+        sa.Column(
+            "id",
+            sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+            primary_key=True,
+        ),
+        sa.Column("resource_id", sqlmodel.sql.sqltypes.GUID(), nullable=False),
+        sa.Column("resource_type", sa.String(length=255), nullable=False),
+        sa.Column(
+            "run_metadata_id",
+            sqlmodel.sql.sqltypes.GUID(),
+            sa.ForeignKey("run_metadata.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+    )
+
+    connection = op.get_bind()
+
+    run_metadata_data = connection.execute(
+        sa.text("""
+            SELECT id, resource_id, resource_type
+            FROM run_metadata
+        """)
+    ).fetchall()
+
+    # Prepare data with new UUIDs for bulk insert
+    resource_data = [
+        {
+            "id": str(uuid.uuid4()),  # Generate a new UUID for each row
+            "resource_id": row.resource_id,
+            "resource_type": row.resource_type,
+            "run_metadata_id": row.id,
+        }
+        for row in run_metadata_data
+    ]
+
+    # Perform bulk insert into `run_metadata_resource`
+    if resource_data:  # Only perform insert if there's data to migrate
+        op.bulk_insert(
+            sa.table(
+                "run_metadata_resource",
+                sa.Column("id", sqlmodel.sql.sqltypes.GUID(), nullable=False),
+                sa.Column(
+                    "resource_id", sqlmodel.sql.sqltypes.GUID(), nullable=False
+                ),
+                sa.Column(
+                    "resource_type", sa.String(length=255), nullable=False
+                ),
+                sa.Column(
+                    "run_metadata_id",
+                    sqlmodel.sql.sqltypes.GUID(),
+                    nullable=False,
+                ),  # Changed to BIGINT
+            ),
+            resource_data,
+        )
+
+    op.drop_column("run_metadata", "resource_id")
+    op.drop_column("run_metadata", "resource_type")
+
+    op.add_column(
+        "run_metadata",
+        sa.Column(
+            "publisher_step_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+        ),
+    )
+
+
+def downgrade() -> None:
+    """Reverts the 'run_metadata_resource' table and migrates data back."""
+    # Recreate the `resource_id` and `resource_type` columns in `run_metadata`
+    op.add_column(
+        "run_metadata",
+        sa.Column("resource_id", sqlmodel.sql.sqltypes.GUID(), nullable=True),
+    )
+    op.add_column(
+        "run_metadata",
+        sa.Column("resource_type", sa.String(length=255), nullable=True),
+    )
+
+    # Migrate data back from `run_metadata_resource` to `run_metadata`
+    connection = op.get_bind()
+
+    # Fetch data from `run_metadata_resource`
+    run_metadata_resource_data = connection.execute(
+        sa.text("""
+            SELECT resource_id, resource_type, run_metadata_id
+            FROM run_metadata_resource
+        """)
+    ).fetchall()
+
+    # Update `run_metadata` with the data from `run_metadata_resource`
+    for row in run_metadata_resource_data:
+        connection.execute(
+            sa.text("""
+                UPDATE run_metadata
+                SET resource_id = :resource_id, resource_type = :resource_type
+                WHERE id = :run_metadata_id
+            """),
+            {
+                "resource_id": row.resource_id,
+                "resource_type": row.resource_type,
+                "run_metadata_id": row.run_metadata_id,
+            },
+        )
+
+    # Drop the `run_metadata_resource` table
+    op.drop_table("run_metadata_resource")
+
+    # Drop the cached column
+    op.drop_column("run_metadata", "publisher_step_id")

zenml/zen_stores/migrations/versions/ec6307720f92_simplify_model_version_links.py

@@ -59,12 +59,13 @@ def _migrate_artifact_type() -> None:
                 {"id_": artifact_version_id, "type": "ServiceArtifact"}
             )
 
-    connection.execute(
-        sa.update(artifact_version_table).where(
-            artifact_version_table.c.id == sa.bindparam("id_")
-        ),
-        updates,
-    )
+    if updates:
+        connection.execute(
+            sa.update(artifact_version_table).where(
+                artifact_version_table.c.id == sa.bindparam("id_")
+            ),
+            updates,
+        )
 
 
 def upgrade() -> None:

zenml/zen_stores/schemas/__init__.py

@@ -39,7 +39,10 @@ from zenml.zen_stores.schemas.pipeline_deployment_schemas import (
 from zenml.zen_stores.schemas.pipeline_run_schemas import PipelineRunSchema
 from zenml.zen_stores.schemas.pipeline_schemas import PipelineSchema
 from zenml.zen_stores.schemas.workspace_schemas import WorkspaceSchema
-from zenml.zen_stores.schemas.run_metadata_schemas import RunMetadataSchema
+from zenml.zen_stores.schemas.run_metadata_schemas import (
+    RunMetadataResourceSchema,
+    RunMetadataSchema,
+)
 from zenml.zen_stores.schemas.schedule_schema import ScheduleSchema
 from zenml.zen_stores.schemas.secret_schemas import SecretSchema
 from zenml.zen_stores.schemas.service_schemas import ServiceSchema
@@ -90,6 +93,7 @@ __all__ = [
     "PipelineDeploymentSchema",
     "PipelineRunSchema",
     "PipelineSchema",
+    "RunMetadataResourceSchema",
     "RunMetadataSchema",
     "ScheduleSchema",
     "SecretSchema",

zenml/zen_stores/schemas/artifact_schemas.py

@@ -13,7 +13,6 @@
 #  permissions and limitations under the License.
 """SQLModel implementation of artifact table."""
 
-import json
 from datetime import datetime
 from typing import TYPE_CHECKING, Any, List, Optional
 from uuid import UUID
@@ -50,6 +49,7 @@ from zenml.zen_stores.schemas.step_run_schemas import (
     StepRunOutputArtifactSchema,
 )
 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:
@@ -59,7 +59,9 @@ if TYPE_CHECKING:
     from zenml.zen_stores.schemas.model_schemas import (
         ModelVersionArtifactSchema,
     )
-    from zenml.zen_stores.schemas.run_metadata_schemas import RunMetadataSchema
+    from zenml.zen_stores.schemas.run_metadata_schemas import (
+        RunMetadataResourceSchema,
+    )
     from zenml.zen_stores.schemas.tag_schemas import TagResourceSchema
 
 
@@ -171,7 +173,7 @@ class ArtifactSchema(NamedSchema, table=True):
         return self
 
 
-class ArtifactVersionSchema(BaseSchema, table=True):
+class ArtifactVersionSchema(BaseSchema, RunMetadataInterface, table=True):
     """SQL Model for artifact versions."""
 
     __tablename__ = "artifact_version"
@@ -242,12 +244,12 @@ class ArtifactVersionSchema(BaseSchema, table=True):
     workspace: "WorkspaceSchema" = Relationship(
         back_populates="artifact_versions"
     )
-    run_metadata: List["RunMetadataSchema"] = Relationship(
-        back_populates="artifact_version",
+    run_metadata_resources: List["RunMetadataResourceSchema"] = Relationship(
+        back_populates="artifact_versions",
         sa_relationship_kwargs=dict(
-            primaryjoin=f"and_(RunMetadataSchema.resource_type=='{MetadataResourceTypes.ARTIFACT_VERSION.value}', foreign(RunMetadataSchema.resource_id)==ArtifactVersionSchema.id)",
+            primaryjoin=f"and_(RunMetadataResourceSchema.resource_type=='{MetadataResourceTypes.ARTIFACT_VERSION.value}', foreign(RunMetadataResourceSchema.resource_id)==ArtifactVersionSchema.id)",
             cascade="delete",
-            overlaps="run_metadata",
+            overlaps="run_metadata_resources",
         ),
     )
     output_of_step_runs: List["StepRunOutputArtifactSchema"] = Relationship(
@@ -352,8 +354,9 @@ class ArtifactVersionSchema(BaseSchema, table=True):
                 producer_step_run_id = step_run.original_step_run_id
 
         # Create the body of the model
+        artifact = self.artifact.to_model()
         body = ArtifactVersionResponseBody(
-            artifact=self.artifact.to_model(),
+            artifact=artifact,
             version=self.version or str(self.version_number),
             user=self.user.to_model() if self.user else None,
             uri=self.uri,
@@ -375,9 +378,7 @@ class ArtifactVersionSchema(BaseSchema, table=True):
                 workspace=self.workspace.to_model(),
                 producer_step_run_id=producer_step_run_id,
                 visualizations=[v.to_model() for v in self.visualizations],
-                run_metadata={
-                    m.key: json.loads(m.value) for m in self.run_metadata
-                },
+                run_metadata=self.fetch_metadata(),
             )
 
         resources = None

zenml/zen_stores/schemas/component_schemas.py

@@ -56,7 +56,6 @@ class StackComponentSchema(NamedSchema, table=True):
     flavor: str
     configuration: bytes
     labels: Optional[bytes]
-    component_spec_path: Optional[str]
 
     workspace_id: UUID = build_foreign_key_field(
         source=__tablename__,
@@ -135,7 +134,6 @@ class StackComponentSchema(NamedSchema, table=True):
             name=request.name,
             workspace_id=request.workspace,
             user_id=request.user,
-            component_spec_path=request.component_spec_path,
             type=request.type,
             flavor=request.flavor,
             configuration=base64.b64encode(
@@ -218,7 +216,6 @@ class StackComponentSchema(NamedSchema, table=True):
                 labels=json.loads(base64.b64decode(self.labels).decode())
                 if self.labels
                 else None,
-                component_spec_path=self.component_spec_path,
                 connector_resource_id=self.connector_resource_id,
                 connector=self.connector.to_model()
                 if self.connector