genesis-flow 1.0.0__py3-none-any.whl

mlflow/store/db_migrations/versions/84291f40a231_add_run_link_to_model_version.py

@@ -0,0 +1,26 @@
+"""add run_link to model_version
+
+Revision ID: 84291f40a231
+Revises: 27a6a02d2cf1
+Create Date: 2020-07-16 13:45:56.178092
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "84291f40a231"
+down_revision = "27a6a02d2cf1"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column(
+        "model_versions", sa.Column("run_link", sa.String(500), nullable=True, default=None)
+    )
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/867495a8f9d4_add_trace_tables.py

@@ -0,0 +1,90 @@
+"""add trace tables
+
+Revision ID: 867495a8f9d4
+Revises: acf3f17fdcc7
+Create Date: 2024-04-27 12:29:25.178685
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+from mlflow.store.tracking.dbmodels.models import SqlTraceInfo, SqlTraceMetadata, SqlTraceTag
+
+# revision identifiers, used by Alembic.
+revision = "867495a8f9d4"
+down_revision = "acf3f17fdcc7"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.create_table(
+        SqlTraceInfo.__tablename__,
+        sa.Column("request_id", sa.String(length=50), primary_key=True, nullable=False),
+        sa.Column(
+            "experiment_id",
+            sa.Integer(),
+            sa.ForeignKey(
+                column="experiments.experiment_id",
+                name="fk_trace_info_experiment_id",
+            ),
+            nullable=False,
+        ),
+        sa.Column("timestamp_ms", sa.BigInteger(), nullable=False),
+        sa.Column("execution_time_ms", sa.BigInteger(), nullable=True),
+        sa.Column("status", sa.String(length=50), nullable=False),
+        sa.PrimaryKeyConstraint("request_id", name="trace_info_pk"),
+        sa.Index(
+            f"index_{SqlTraceInfo.__tablename__}_experiment_id_timestamp_ms",
+            "experiment_id",
+            "timestamp_ms",
+            unique=False,
+        ),
+    )
+    op.create_table(
+        SqlTraceTag.__tablename__,
+        sa.Column("key", sa.String(length=250), primary_key=True, nullable=False),
+        sa.Column("value", sa.String(length=8000), nullable=True),
+        sa.Column(
+            "request_id",
+            sa.String(length=50),
+            sa.ForeignKey(
+                column=SqlTraceInfo.request_id,
+                name=f"fk_{SqlTraceTag.__tablename__}_request_id",
+            ),
+            nullable=False,
+            primary_key=True,
+        ),
+        sa.PrimaryKeyConstraint("key", "request_id", name="trace_tag_pk"),
+        sa.Index(
+            f"index_{SqlTraceTag.__tablename__}_request_id",
+            "request_id",
+            unique=False,
+        ),
+    )
+    op.create_table(
+        SqlTraceMetadata.__tablename__,
+        sa.Column("key", sa.String(length=250), primary_key=True, nullable=False),
+        sa.Column("value", sa.String(length=8000), nullable=True),
+        sa.Column(
+            "request_id",
+            sa.String(length=50),
+            sa.ForeignKey(
+                column=SqlTraceInfo.request_id,
+                name=f"fk_{SqlTraceMetadata.__tablename__}_request_id",
+            ),
+            nullable=False,
+            primary_key=True,
+        ),
+        sa.PrimaryKeyConstraint("key", "request_id", name="trace_request_metadata_pk"),
+        sa.Index(
+            f"index_{SqlTraceMetadata.__tablename__}_request_id",
+            "request_id",
+            unique=False,
+        ),
+    )
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/89d4b8295536_create_latest_metrics_table.py

@@ -0,0 +1,169 @@
+"""create latest metrics table
+
+Revision ID: 89d4b8295536
+Revises: 7ac759974ad8
+Create Date: 2019-08-20 11:53:28.178479
+
+"""
+
+import logging
+import time
+
+from alembic import op
+from sqlalchemy import (
+    BigInteger,
+    Boolean,
+    Column,
+    Float,
+    ForeignKey,
+    PrimaryKeyConstraint,
+    String,
+    and_,
+    distinct,
+    func,
+    orm,
+)
+
+from mlflow.store.tracking.dbmodels.models import SqlLatestMetric, SqlMetric
+
+_logger = logging.getLogger(__name__)
+_logger.setLevel(logging.INFO)
+
+# revision identifiers, used by Alembic.
+revision = "89d4b8295536"
+down_revision = "7ac759974ad8"
+branch_labels = None
+depends_on = None
+
+
+def _describe_migration_if_necessary(session):
+    """
+    If the targeted database contains any metric entries, this function emits important,
+    database-specific information about the ``create_latest_metrics_table`` migration.
+    If the targeted database does *not* contain any metric entries, this output is omitted
+    in order to avoid superfluous log output when initializing a new Tracking database.
+    """
+    num_metric_entries = session.query(SqlMetric).count()
+    if num_metric_entries <= 0:
+        return
+
+    _logger.warning(
+        "**IMPORTANT**: This migration creates a `latest_metrics` table and populates it with the"
+        " latest metric entry for each unique (run_id, metric_key) tuple. Latest metric entries are"
+        " computed based on step, timestamp, and value. This migration may take a long time for"
+        " databases containing a large number of metric entries. Please refer to {readme_link} for"
+        " information about this migration, including how to estimate migration size and how to"
+        " restore your database to its original state if the migration is unsuccessful. If you"
+        " encounter failures while executing this migration, please file a GitHub issue at"
+        " {issues_link}.".format(
+            readme_link=(
+                "https://github.com/mlflow/mlflow/blob/master/mlflow/store/db_migrations/README.md"
+                "#89d4b8295536_create_latest_metrics_table"
+            ),
+            issues_link="https://github.com/mlflow/mlflow/issues",
+        )
+    )
+
+    num_metric_keys = (
+        session.query(SqlMetric.run_uuid, SqlMetric.key)
+        .group_by(SqlMetric.run_uuid, SqlMetric.key)
+        .count()
+    )
+    num_runs_containing_metrics = session.query(distinct(SqlMetric.run_uuid)).count()
+    _logger.info(
+        "This tracking database has {num_metric_entries} total metric entries for {num_metric_keys}"
+        " unique metrics across {num_runs} runs.".format(
+            num_metric_entries=num_metric_entries,
+            num_metric_keys=num_metric_keys,
+            num_runs=num_runs_containing_metrics,
+        )
+    )
+
+
+def _get_latest_metrics_for_runs(session):
+    metrics_with_max_step = (
+        session.query(SqlMetric.run_uuid, SqlMetric.key, func.max(SqlMetric.step).label("step"))
+        .group_by(SqlMetric.key, SqlMetric.run_uuid)
+        .subquery("metrics_with_max_step")
+    )
+    metrics_with_max_timestamp = (
+        session.query(
+            SqlMetric.run_uuid,
+            SqlMetric.key,
+            SqlMetric.step,
+            func.max(SqlMetric.timestamp).label("timestamp"),
+        )
+        .join(
+            metrics_with_max_step,
+            and_(
+                SqlMetric.step == metrics_with_max_step.c.step,
+                SqlMetric.run_uuid == metrics_with_max_step.c.run_uuid,
+                SqlMetric.key == metrics_with_max_step.c.key,
+            ),
+        )
+        .group_by(SqlMetric.key, SqlMetric.run_uuid, SqlMetric.step)
+        .subquery("metrics_with_max_timestamp")
+    )
+    return (
+        session.query(
+            SqlMetric.run_uuid,
+            SqlMetric.key,
+            SqlMetric.step,
+            SqlMetric.timestamp,
+            func.max(SqlMetric.value).label("value"),
+            SqlMetric.is_nan,
+        )
+        .join(
+            metrics_with_max_timestamp,
+            and_(
+                SqlMetric.timestamp == metrics_with_max_timestamp.c.timestamp,
+                SqlMetric.run_uuid == metrics_with_max_timestamp.c.run_uuid,
+                SqlMetric.key == metrics_with_max_timestamp.c.key,
+                SqlMetric.step == metrics_with_max_timestamp.c.step,
+            ),
+        )
+        .group_by(
+            SqlMetric.run_uuid, SqlMetric.key, SqlMetric.step, SqlMetric.timestamp, SqlMetric.is_nan
+        )
+        .all()
+    )
+
+
+def upgrade():
+    bind = op.get_bind()
+    session = orm.Session(bind=bind)
+
+    _describe_migration_if_necessary(session)
+    all_latest_metrics = _get_latest_metrics_for_runs(session=session)
+
+    op.create_table(
+        SqlLatestMetric.__tablename__,
+        Column("key", String(length=250)),
+        Column("value", Float(precision=53), nullable=False),
+        Column("timestamp", BigInteger, default=lambda: int(time.time())),
+        Column("step", BigInteger, default=0, nullable=False),
+        Column("is_nan", Boolean, default=False, nullable=False),
+        Column("run_uuid", String(length=32), ForeignKey("runs.run_uuid"), nullable=False),
+        PrimaryKeyConstraint("key", "run_uuid", name="latest_metric_pk"),
+    )
+
+    session.add_all(
+        [
+            SqlLatestMetric(
+                run_uuid=run_uuid,
+                key=key,
+                step=step,
+                timestamp=timestamp,
+                value=value,
+                is_nan=is_nan,
+            )
+            for run_uuid, key, step, timestamp, value, is_nan in all_latest_metrics
+        ]
+    )
+    session.commit()
+
+    _logger.info("Migration complete!")
+
+
+def downgrade():
+    op.drop_table(SqlLatestMetric.__tablename__)

mlflow/store/db_migrations/versions/90e64c465722_migrate_user_column_to_tags.py

@@ -0,0 +1,64 @@
+"""migrate user column to tags
+
+Revision ID: 90e64c465722
+Revises: 451aebb31d03
+Create Date: 2019-05-29 10:43:52.919427
+
+"""
+
+from alembic import op
+from sqlalchemy import Column, ForeignKey, Integer, PrimaryKeyConstraint, String, orm
+from sqlalchemy.orm import backref, declarative_base, relationship
+
+from mlflow.utils.mlflow_tags import MLFLOW_USER
+
+# revision identifiers, used by Alembic.
+revision = "90e64c465722"
+down_revision = "451aebb31d03"
+branch_labels = None
+depends_on = None
+
+
+Base = declarative_base()
+
+
+class SqlRun(Base):
+    __tablename__ = "runs"
+    run_uuid = Column(String(32), nullable=False)
+    user_id = Column(String(256), nullable=True, default=None)
+    experiment_id = Column(Integer)
+
+    __table_args__ = (PrimaryKeyConstraint("experiment_id", name="experiment_pk"),)
+
+
+class SqlTag(Base):
+    __tablename__ = "tags"
+    key = Column(String(250))
+    value = Column(String(250), nullable=True)
+    run_uuid = Column(String(32), ForeignKey("runs.run_uuid"))
+    run = relationship("SqlRun", backref=backref("tags", cascade="all"))
+
+    __table_args__ = (PrimaryKeyConstraint("key", "run_uuid", name="tag_pk"),)
+
+
+def upgrade():
+    bind = op.get_bind()
+    session = orm.Session(bind=bind)
+    runs = session.query(SqlRun).all()
+    for run in runs:
+        if not run.user_id:
+            continue
+
+        tag_exists = False
+        for tag in run.tags:
+            if tag.key == MLFLOW_USER:
+                tag_exists = True
+        if tag_exists:
+            continue
+
+        session.merge(SqlTag(run_uuid=run.run_uuid, key=MLFLOW_USER, value=run.user_id))
+    session.commit()
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/97727af70f4d_creation_time_last_update_time_experiments.py

@@ -0,0 +1,25 @@
+"""Add creation_time and last_update_time to experiments table
+
+Revision ID: 97727af70f4d
+Revises: cc1f77228345
+Create Date: 2022-08-26 21:16:59.164858
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "97727af70f4d"
+down_revision = "cc1f77228345"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column("experiments", sa.Column("creation_time", sa.BigInteger(), nullable=True))
+    op.add_column("experiments", sa.Column("last_update_time", sa.BigInteger(), nullable=True))
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/a8c4a736bde6_allow_nulls_for_run_id.py

@@ -0,0 +1,27 @@
+"""allow nulls for run_id
+
+Revision ID: a8c4a736bde6
+Revises: 84291f40a231
+Create Date: 2020-12-02 12:14:35.220815
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+from mlflow.store.model_registry.dbmodels.models import SqlModelVersion
+
+# revision identifiers, used by Alembic.
+revision = "a8c4a736bde6"
+down_revision = "84291f40a231"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    with op.batch_alter_table(SqlModelVersion.__tablename__) as batch_op:
+        batch_op.alter_column("run_id", nullable=True, existing_type=sa.VARCHAR(32))
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/acf3f17fdcc7_add_storage_location_field_to_model_.py

@@ -0,0 +1,29 @@
+"""add storage location field to model versions
+
+Revision ID: acf3f17fdcc7
+Revises: 2d6e25af4d3e
+Create Date: 2023-10-23 15:26:53.062080
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+from mlflow.store.model_registry.dbmodels.models import SqlModelVersion
+
+# revision identifiers, used by Alembic.
+revision = "acf3f17fdcc7"
+down_revision = "2d6e25af4d3e"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column(
+        SqlModelVersion.__tablename__,
+        sa.Column("storage_location", sa.String(500), nullable=True, default=None),
+    )
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/bd07f7e963c5_create_index_on_run_uuid.py

@@ -0,0 +1,26 @@
+"""create index on run_uuid
+
+Revision ID: bd07f7e963c5
+Revises: c48cb773bb87
+Create Date: 2022-03-03 10:14:34.037978
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "bd07f7e963c5"
+down_revision = "c48cb773bb87"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # As a fix for https://github.com/mlflow/mlflow/issues/3785, create an index on run_uuid columns
+    # that have a foreign key constraint to speed up SQL operations.
+    for table in ["params", "metrics", "latest_metrics", "tags"]:
+        op.create_index(f"index_{table}_run_uuid", table, ["run_uuid"])
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/bda7b8c39065_increase_model_version_tag_value_limit.py

@@ -0,0 +1,38 @@
+"""increase_model_version_tag_value_limit
+
+Revision ID: bda7b8c39065
+Revises: 6953534de441
+Create Date: 2025-06-23 11:05:41.676297
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "bda7b8c39065"
+down_revision = "6953534de441"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Use batch mode for SQLite compatibility
+    with op.batch_alter_table("model_version_tags") as batch_op:
+        # Increase value column from VARCHAR(5000) to TEXT (unlimited)
+        # We use Text type which maps appropriately for each database:
+        # - PostgreSQL: TEXT (up to 1GB)
+        # - MySQL: TEXT (up to 65,535 bytes) or LONGTEXT if needed
+        # - SQLite: TEXT (no limit)
+        # - MSSQL: VARCHAR(MAX) (up to 2GB)
+        batch_op.alter_column(
+            "value",
+            existing_type=sa.String(5000),
+            type_=sa.Text(),
+            existing_nullable=True,
+            existing_server_default=None,
+        )
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/c48cb773bb87_reset_default_value_for_is_nan_in_metrics_table_for_mysql.py

@@ -0,0 +1,41 @@
+"""reset_default_value_for_is_nan_in_metrics_table_for_mysql
+
+Revision ID: c48cb773bb87
+Revises: 39d1c3be5f05
+Create Date: 2021-04-02 15:43:28.466043
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "c48cb773bb87"
+down_revision = "39d1c3be5f05"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # This part of the migration is only relevant for MySQL.
+    # In 39d1c3be5f05_add_is_nan_constraint_for_metrics_tables_if_necessary.py
+    # (added in MLflow 1.15.0), `alter_column` is called on the `is_nan` column in the `metrics`
+    # table without specifying `existing_server_default`. This alters the column default value to
+    # NULL in MySQL (see the doc below).
+    #
+    # https://alembic.sqlalchemy.org/en/latest/ops.html#alembic.operations.Operations.alter_column
+    #
+    # To revert this change, set the default column value to "0" by specifying `server_default`
+    bind = op.get_bind()
+    if bind.engine.name == "mysql":
+        with op.batch_alter_table("metrics") as batch_op:
+            batch_op.alter_column(
+                "is_nan",
+                type_=sa.types.Boolean(create_constraint=True),
+                nullable=False,
+                server_default="0",
+            )
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/cbc13b556ace_add_v3_trace_schema_columns.py

@@ -0,0 +1,31 @@
+"""add V3 trace schema columns
+
+Revision ID: cbc13b556ace
+Revises: bda7b8c39065
+Create Date: 2025-06-17 12:00:00.000000
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "cbc13b556ace"
+down_revision = "bda7b8c39065"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # Add V3 specific columns to trace_info table
+    with op.batch_alter_table("trace_info", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("client_request_id", sa.String(length=50), nullable=True))
+        batch_op.add_column(sa.Column("request_preview", sa.String(length=1000), nullable=True))
+        batch_op.add_column(sa.Column("response_preview", sa.String(length=1000), nullable=True))
+
+
+def downgrade():
+    with op.batch_alter_table("trace_info", schema=None) as batch_op:
+        batch_op.drop_column("response_preview")
+        batch_op.drop_column("request_preview")
+        batch_op.drop_column("client_request_id")

mlflow/store/db_migrations/versions/cc1f77228345_change_param_value_length_to_500.py

@@ -0,0 +1,34 @@
+"""change param value length to 500
+
+Revision ID: cc1f77228345
+Revises: 0c779009ac13
+Create Date: 2022-08-04 22:40:56.960003
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "cc1f77228345"
+down_revision = "0c779009ac13"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    """
+    Enlarge the maximum param value length to 500.
+    """
+    with op.batch_alter_table("params") as batch_op:
+        batch_op.alter_column(
+            "value",
+            existing_type=sa.String(250),
+            type_=sa.String(500),
+            existing_nullable=False,
+            nullable=False,
+        )
+
+
+def downgrade():
+    pass

mlflow/store/db_migrations/versions/cfd24bdc0731_update_run_status_constraint_with_killed.py

@@ -0,0 +1,78 @@
+"""Update run status constraint with killed
+
+Revision ID: cfd24bdc0731
+Revises: 89d4b8295536
+Create Date: 2019-10-11 15:55:10.853449
+
+"""
+
+import alembic
+from alembic import op
+from packaging.version import Version
+from sqlalchemy import CheckConstraint, Enum
+
+from mlflow.entities import RunStatus, ViewType
+from mlflow.entities.lifecycle_stage import LifecycleStage
+from mlflow.store.tracking.dbmodels.models import SourceTypes, SqlRun
+
+# revision identifiers, used by Alembic.
+revision = "cfd24bdc0731"
+down_revision = "2b4d017a5e9b"
+branch_labels = None
+depends_on = None
+
+old_run_statuses = [
+    RunStatus.to_string(RunStatus.SCHEDULED),
+    RunStatus.to_string(RunStatus.FAILED),
+    RunStatus.to_string(RunStatus.FINISHED),
+    RunStatus.to_string(RunStatus.RUNNING),
+]
+
+new_run_statuses = [*old_run_statuses, RunStatus.to_string(RunStatus.KILLED)]
+
+# Certain SQL backends (e.g., SQLite) do not preserve CHECK constraints during migrations.
+# For these backends, CHECK constraints must be specified as table arguments. Here, we define
+# the collection of CHECK constraints that should be preserved when performing the migration.
+# The "status" constraint is excluded from this set because it is explicitly modified
+# within the migration's `upgrade()` routine.
+check_constraint_table_args = [
+    CheckConstraint(SqlRun.source_type.in_(SourceTypes), name="source_type"),
+    CheckConstraint(
+        SqlRun.lifecycle_stage.in_(LifecycleStage.view_type_to_stages(ViewType.ALL)),
+        name="runs_lifecycle_stage",
+    ),
+]
+
+
+def upgrade():
+    # In alembic >= 1.7.0, `table_args` is unnecessary since CHECK constraints are preserved
+    # during migrations.
+    table_args = (
+        [] if Version(alembic.__version__) >= Version("1.7.0") else check_constraint_table_args
+    )
+    with op.batch_alter_table("runs", table_args=table_args) as batch_op:
+        # Transform the "status" column to an `Enum` and define a new check constraint. Specify
+        # `native_enum=False` to create a check constraint rather than a
+        # database-backend-dependent enum (see https://docs.sqlalchemy.org/en/13/core/
+        # type_basics.html#sqlalchemy.types.Enum.params.native_enum)
+        batch_op.alter_column(
+            "status",
+            type_=Enum(
+                *new_run_statuses,
+                create_constraint=True,
+                native_enum=False,
+            ),
+            existing_type=Enum(
+                *old_run_statuses,
+                create_constraint=True,
+                native_enum=False,
+                name="status",
+            ),
+        )
+
+
+def downgrade():
+    # Omit downgrade logic for now - we don't currently provide users a command/API for
+    # reverting a database migration, instead recommending that they take a database backup
+    # before running the migration.
+    pass