zenml-nightly 0.75.0.dev20250313__py3-none-any.whl → 0.75.0.dev20250315__py3-none-any.whl

zenml/zen_stores/migrations/versions/12eff0206201_rename_workspace_to_project.py

@@ -0,0 +1,768 @@
+"""rename workspace to project [12eff0206201].
+
+Revision ID: 12eff0206201
+Revises: cbc6acd71f92
+Create Date: 2025-03-12 22:34:29.670973
+
+"""
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "12eff0206201"
+down_revision = "cbc6acd71f92"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    """Upgrade database schema and/or data, creating a new revision."""
+    # Create the new project table first
+    op.create_table(
+        "project",
+        sa.Column("id", sqlmodel.sql.sqltypes.GUID(), nullable=False),
+        sa.Column("created", sa.DateTime(), nullable=False),
+        sa.Column("updated", sa.DateTime(), nullable=False),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column(
+            "display_name", sqlmodel.sql.sqltypes.AutoString(), nullable=False
+        ),
+        sa.Column(
+            "description", sqlmodel.sql.sqltypes.AutoString(), nullable=False
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("name", name="unique_project_name"),
+    )
+
+    # Copy data from workspace to project
+    op.execute(
+        """
+        INSERT INTO `project` (id, created, updated, name, display_name, description)
+        SELECT id, created, updated, name, display_name, description
+        FROM `workspace`
+        """
+    )
+
+    # For each table that needs migration, we'll:
+    # 1. Add new column as nullable
+    # 2. Copy data
+    # 3. Make column non-nullable and add constraints
+
+    # Example for one table (repeat pattern for others)
+    with op.batch_alter_table("action", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `action` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("action", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_action_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_action_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_action_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_action_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("artifact", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `artifact` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("artifact", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_artifact_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_artifact_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_artifact_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_artifact_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("artifact_version", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `artifact_version` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("artifact_version", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_artifact_version_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_artifact_version_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("code_reference", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `code_reference` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("code_reference", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_code_reference_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_code_reference_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("code_repository", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `code_repository` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("code_repository", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_code_repository_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_code_repository_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_code_repository_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_code_repository_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("event_source", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `event_source` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("event_source", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_event_source_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_event_source_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_event_source_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_event_source_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("model", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `model` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("model", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_model_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_model_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_model_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_model_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("model_version", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `model_version` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("model_version", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_model_version_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_model_version_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("pipeline", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `pipeline` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("pipeline", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_pipeline_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_pipeline_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_pipeline_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_pipeline_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # pipeline_build table
+    with op.batch_alter_table("pipeline_build", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `pipeline_build` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("pipeline_build", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_pipeline_build_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_pipeline_build_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # pipeline_deployment table
+    with op.batch_alter_table("pipeline_deployment", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `pipeline_deployment` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("pipeline_deployment", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_pipeline_deployment_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_pipeline_deployment_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # pipeline_run table
+    with op.batch_alter_table("pipeline_run", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `pipeline_run` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("pipeline_run", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_run_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_run_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_pipeline_run_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_pipeline_run_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # run_metadata table
+    with op.batch_alter_table("run_metadata", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `run_metadata` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("run_metadata", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_run_metadata_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_run_metadata_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # run_template table
+    with op.batch_alter_table("run_template", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `run_template` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("run_template", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_template_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_template_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_run_template_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_run_template_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # schedule table
+    with op.batch_alter_table("schedule", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `schedule` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("schedule", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_schedule_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_schedule_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_schedule_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_schedule_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # service table
+    with op.batch_alter_table("service", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `service` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("service", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_service_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_service_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # step_run table
+    with op.batch_alter_table("step_run", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `step_run` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("step_run", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "fk_step_run_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_step_run_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    # trigger table
+    with op.batch_alter_table("trigger", schema=None) as batch_op:
+        # Phase 1: Add new column as nullable
+        batch_op.add_column(
+            sa.Column(
+                "project_id", sqlmodel.sql.sqltypes.GUID(), nullable=True
+            )
+        )
+
+    # Phase 2: Copy data
+    op.execute(
+        """
+        UPDATE `trigger` 
+        SET project_id = workspace_id
+        """
+    )
+
+    # Phase 3: Add constraints and drop old column
+    with op.batch_alter_table("trigger", schema=None) as batch_op:
+        batch_op.alter_column(
+            "project_id",
+            existing_type=sqlmodel.sql.sqltypes.GUID(),
+            nullable=False,
+        )
+        batch_op.drop_constraint(
+            "unique_trigger_name_in_workspace", type_="unique"
+        )
+        batch_op.create_unique_constraint(
+            "unique_trigger_name_in_project", ["name", "project_id"]
+        )
+        batch_op.drop_constraint(
+            "fk_trigger_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.create_foreign_key(
+            "fk_trigger_project_id_project",
+            "project",
+            ["project_id"],
+            ["id"],
+            ondelete="CASCADE",
+        )
+        batch_op.drop_column("workspace_id")
+
+    with op.batch_alter_table("user", schema=None) as batch_op:
+        batch_op.drop_constraint(
+            "fk_user_default_workspace_id_workspace", type_="foreignkey"
+        )
+        batch_op.drop_column("default_workspace_id")
+
+    op.drop_table("workspace")
+
+
+def downgrade() -> None:
+    """Downgrade database schema and/or data back to the previous revision.
+
+    Raises:
+        NotImplementedError: Downgrade is not implemented
+    """
+    raise NotImplementedError("Downgrade is not implemented")