codexLB-up 1.25.0b10__py3-none-any.whl

app/db/alembic/versions/20260415_160000_add_request_logs_response_lookup_index.py

@@ -0,0 +1,67 @@
+"""add request_logs response lookup index
+
+Revision ID: 20260415_160000_add_request_logs_response_lookup_index
+Revises: 20260413_000000_add_accounts_blocked_at
+Create Date: 2026-04-15
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "20260415_160000_add_request_logs_response_lookup_index"
+down_revision = "20260413_000000_add_accounts_blocked_at"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    existing_columns = {column["name"] for column in inspector.get_columns("request_logs")}
+    if "session_id" not in existing_columns:
+        op.add_column("request_logs", sa.Column("session_id", sa.String(), nullable=True))
+
+    op.create_index(
+        "idx_logs_request_status_api_key_time",
+        "request_logs",
+        [
+            "request_id",
+            "status",
+            "api_key_id",
+            sa.text("requested_at DESC"),
+            sa.text("id DESC"),
+        ],
+        unique=False,
+        if_not_exists=True,
+    )
+    op.create_index(
+        "idx_logs_request_status_api_key_session_time",
+        "request_logs",
+        [
+            "request_id",
+            "status",
+            "api_key_id",
+            "session_id",
+            sa.text("requested_at DESC"),
+            sa.text("id DESC"),
+        ],
+        unique=False,
+        if_not_exists=True,
+    )
+
+
+def downgrade() -> None:
+    op.drop_index(
+        "idx_logs_request_status_api_key_session_time",
+        table_name="request_logs",
+        if_exists=True,
+    )
+    op.drop_index(
+        "idx_logs_request_status_api_key_time",
+        table_name="request_logs",
+        if_exists=True,
+    )
+    op.drop_column("request_logs", "session_id")

app/db/alembic/versions/20260417_000000_add_request_log_plan_type.py

@@ -0,0 +1,44 @@
+"""add plan_type snapshot to request_logs
+
+Revision ID: 20260417_000000_add_request_log_plan_type
+Revises: 20260413_000000_add_accounts_blocked_at
+Create Date: 2026-04-17
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "20260417_000000_add_request_log_plan_type"
+down_revision = "20260413_000000_add_accounts_blocked_at"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    if not inspector.has_table("request_logs"):
+        return
+
+    columns = {column["name"] for column in inspector.get_columns("request_logs")}
+    if "plan_type" in columns:
+        return
+
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.add_column(sa.Column("plan_type", sa.String(), nullable=True))
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+    if not inspector.has_table("request_logs"):
+        return
+
+    columns = {column["name"] for column in inspector.get_columns("request_logs")}
+    if "plan_type" not in columns:
+        return
+
+    with op.batch_alter_table("request_logs") as batch_op:
+        batch_op.drop_column("plan_type")

app/db/alembic/versions/20260418_190000_add_automation_runs_cycle_key.py

@@ -0,0 +1,87 @@
+"""add cycle key to automation runs
+
+Revision ID: 20260418_190000_add_automation_runs_cycle_key
+Revises: 20260415_160000_add_automations_tables
+Create Date: 2026-04-18
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260418_190000_add_automation_runs_cycle_key"
+down_revision = "20260415_160000_add_automations_tables"
+branch_labels = None
+depends_on = None
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def _index_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(index["name"]) for index in inspector.get_indexes(table_name) if index.get("name")}
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name")}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if not _table_exists(bind, "automation_runs"):
+        return
+
+    run_columns = _column_names(bind, "automation_runs")
+    if "cycle_key" not in run_columns:
+        op.add_column(
+            "automation_runs",
+            sa.Column("cycle_key", sa.String(length=160), nullable=True),
+        )
+        op.execute("UPDATE automation_runs SET cycle_key = slot_key WHERE cycle_key IS NULL OR cycle_key = ''")
+        if bind.dialect.name == "sqlite":
+            with op.batch_alter_table("automation_runs", recreate="always") as batch_op:
+                batch_op.alter_column(
+                    "cycle_key",
+                    existing_type=sa.String(length=160),
+                    nullable=False,
+                )
+        else:
+            op.alter_column(
+                "automation_runs",
+                "cycle_key",
+                existing_type=sa.String(length=160),
+                nullable=False,
+            )
+
+    run_indexes = _index_names(bind, "automation_runs")
+    if "idx_automation_runs_cycle_key_started_at" not in run_indexes:
+        op.create_index(
+            "idx_automation_runs_cycle_key_started_at",
+            "automation_runs",
+            ["cycle_key", "started_at"],
+            unique=False,
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if not _table_exists(bind, "automation_runs"):
+        return
+
+    run_indexes = _index_names(bind, "automation_runs")
+    if "idx_automation_runs_cycle_key_started_at" in run_indexes:
+        op.drop_index("idx_automation_runs_cycle_key_started_at", table_name="automation_runs")
+
+    run_columns = _column_names(bind, "automation_runs")
+    if "cycle_key" in run_columns:
+        op.drop_column("automation_runs", "cycle_key")

app/db/alembic/versions/20260419_000000_add_automation_run_cycle_metadata.py

@@ -0,0 +1,56 @@
+"""add automation run cycle metadata columns
+
+Revision ID: 20260419_000000_add_automation_run_cycle_metadata
+Revises: 20260418_190000_add_automation_runs_cycle_key
+Create Date: 2026-04-19
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260419_000000_add_automation_run_cycle_metadata"
+down_revision = "20260418_190000_add_automation_runs_cycle_key"
+branch_labels = None
+depends_on = None
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name")}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if not _table_exists(bind, "automation_runs"):
+        return
+
+    run_columns = _column_names(bind, "automation_runs")
+    if "cycle_expected_accounts" not in run_columns:
+        op.add_column("automation_runs", sa.Column("cycle_expected_accounts", sa.Integer(), nullable=True))
+    if "cycle_window_end" not in run_columns:
+        op.add_column("automation_runs", sa.Column("cycle_window_end", sa.DateTime(), nullable=True))
+
+    op.execute("UPDATE automation_runs SET cycle_expected_accounts = 0 WHERE cycle_expected_accounts IS NULL")
+    op.execute("UPDATE automation_runs SET cycle_window_end = scheduled_for WHERE cycle_window_end IS NULL")
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if not _table_exists(bind, "automation_runs"):
+        return
+
+    run_columns = _column_names(bind, "automation_runs")
+    if "cycle_window_end" in run_columns:
+        op.drop_column("automation_runs", "cycle_window_end")
+    if "cycle_expected_accounts" in run_columns:
+        op.drop_column("automation_runs", "cycle_expected_accounts")

app/db/alembic/versions/20260419_020000_add_automation_run_cycles_snapshot_tables.py

@@ -0,0 +1,342 @@
+"""add automation run cycle snapshot tables
+
+Revision ID: 20260419_020000_add_automation_run_cycles_snapshot_tables
+Revises: 20260419_000000_add_automation_run_cycle_metadata
+Create Date: 2026-04-19
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TypedDict
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260419_020000_add_automation_run_cycles_snapshot_tables"
+down_revision = "20260419_000000_add_automation_run_cycle_metadata"
+branch_labels = None
+depends_on = None
+
+
+class _ObservedRunRow(TypedDict):
+    cycle_key: str
+    job_id: str
+    trigger: str
+    include_paused_accounts: bool
+    account_id: str | None
+    scheduled_for: datetime
+    cycle_window_end: datetime | None
+    created_at: datetime
+
+
+class _ObservedCycleSnapshot(TypedDict):
+    cycle_key: str
+    job_id: str
+    trigger: str
+    cycle_expected_accounts: int
+    cycle_window_end: datetime | None
+    include_paused_accounts: bool
+    created_at: datetime
+    accounts: list[tuple[str, datetime]]
+
+
+class _MutableCycleSnapshot(TypedDict):
+    job_id: str
+    trigger: str
+    cycle_window_end: datetime | None
+    include_paused_accounts: bool
+    created_at: datetime
+    accounts: dict[str, datetime]
+
+
+def _table_exists(connection: Connection, table_name: str) -> bool:
+    inspector = sa.inspect(connection)
+    return inspector.has_table(table_name)
+
+
+def _column_names(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name")}
+
+
+def _normalize_legacy_manual_cycle_key(value: str) -> str | None:
+    parts = value.split(":")
+    if len(parts) == 3 and parts[0] == "manual" and parts[1] and parts[2]:
+        return value
+    if len(parts) == 4 and parts[0] == "manual" and parts[1] and parts[2]:
+        return f"manual:{parts[1]}:{parts[2]}"
+    return None
+
+
+def _normalize_cycle_key(*, trigger: str, cycle_key: str, slot_key: str) -> str:
+    if trigger == "manual":
+        normalized_cycle_key = _normalize_legacy_manual_cycle_key(cycle_key)
+        if normalized_cycle_key is not None:
+            return normalized_cycle_key
+        normalized_slot_cycle_key = _normalize_legacy_manual_cycle_key(slot_key)
+        if normalized_slot_cycle_key is not None:
+            return normalized_slot_cycle_key
+    return cycle_key
+
+
+def _new_mutable_cycle_snapshot(row: _ObservedRunRow) -> _MutableCycleSnapshot:
+    return {
+        "job_id": row["job_id"],
+        "trigger": row["trigger"],
+        "cycle_window_end": row["cycle_window_end"] or row["scheduled_for"],
+        "include_paused_accounts": row["include_paused_accounts"],
+        "created_at": row["created_at"],
+        "accounts": {},
+    }
+
+
+def _build_cycle_snapshots(rows: list[_ObservedRunRow]) -> list[_ObservedCycleSnapshot]:
+    snapshots: dict[str, _MutableCycleSnapshot] = {}
+    for row in rows:
+        snapshot = snapshots.setdefault(
+            row["cycle_key"],
+            _new_mutable_cycle_snapshot(row),
+        )
+        cycle_window_end = snapshot["cycle_window_end"]
+        if cycle_window_end is None or (
+            row["cycle_window_end"] is not None and row["cycle_window_end"] > cycle_window_end
+        ):
+            snapshot["cycle_window_end"] = row["cycle_window_end"]
+        elif cycle_window_end is None or row["scheduled_for"] > cycle_window_end:
+            snapshot["cycle_window_end"] = row["scheduled_for"]
+
+        if row["created_at"] < snapshot["created_at"]:
+            snapshot["created_at"] = row["created_at"]
+
+        account_id = row["account_id"]
+        if account_id is None:
+            continue
+        scheduled_for = snapshot["accounts"].get(account_id)
+        if scheduled_for is None or row["scheduled_for"] < scheduled_for:
+            snapshot["accounts"][account_id] = row["scheduled_for"]
+
+    normalized_snapshots: list[_ObservedCycleSnapshot] = []
+    for cycle_key, snapshot in snapshots.items():
+        account_rows = sorted(
+            snapshot["accounts"].items(),
+            key=lambda item: (item[1], item[0]),
+        )
+        normalized_snapshots.append(
+            {
+                "cycle_key": cycle_key,
+                "job_id": snapshot["job_id"],
+                "trigger": snapshot["trigger"],
+                "cycle_expected_accounts": len(account_rows),
+                "cycle_window_end": snapshot["cycle_window_end"],
+                "include_paused_accounts": snapshot["include_paused_accounts"],
+                "created_at": snapshot["created_at"],
+                "accounts": account_rows,
+            }
+        )
+    return sorted(normalized_snapshots, key=lambda snapshot: snapshot["cycle_key"])
+
+
+def _create_cycle_tables(connection: Connection) -> None:
+    if not _table_exists(connection, "automation_run_cycles"):
+        op.create_table(
+            "automation_run_cycles",
+            sa.Column("cycle_key", sa.String(length=160), nullable=False),
+            sa.Column("job_id", sa.String(), nullable=False),
+            sa.Column("trigger", sa.String(length=16), nullable=False),
+            sa.Column(
+                "cycle_expected_accounts",
+                sa.Integer(),
+                nullable=False,
+                server_default=sa.text("0"),
+            ),
+            sa.Column("cycle_window_end", sa.DateTime(), nullable=True),
+            sa.Column("include_paused_accounts", sa.Boolean(), nullable=False, server_default=sa.false()),
+            sa.Column(
+                "created_at",
+                sa.DateTime(),
+                nullable=False,
+                server_default=sa.func.now(),
+            ),
+            sa.ForeignKeyConstraint(["job_id"], ["automation_jobs.id"], ondelete="CASCADE"),
+            sa.PrimaryKeyConstraint("cycle_key"),
+        )
+    elif "include_paused_accounts" not in _column_names(connection, "automation_run_cycles"):
+        op.add_column(
+            "automation_run_cycles",
+            sa.Column("include_paused_accounts", sa.Boolean(), nullable=False, server_default=sa.false()),
+        )
+
+    if not _table_exists(connection, "automation_run_cycle_accounts"):
+        op.create_table(
+            "automation_run_cycle_accounts",
+            sa.Column("cycle_key", sa.String(length=160), nullable=False),
+            sa.Column("account_id", sa.String(), nullable=False),
+            sa.Column("position", sa.Integer(), nullable=False),
+            sa.Column("scheduled_for", sa.DateTime(), nullable=False),
+            sa.Column(
+                "created_at",
+                sa.DateTime(),
+                nullable=False,
+                server_default=sa.func.now(),
+            ),
+            sa.ForeignKeyConstraint(
+                ["cycle_key"],
+                ["automation_run_cycles.cycle_key"],
+                ondelete="CASCADE",
+            ),
+            sa.PrimaryKeyConstraint("cycle_key", "account_id"),
+            sa.UniqueConstraint("cycle_key", "position", name="uq_automation_run_cycle_accounts_position"),
+        )
+
+
+def _backfill_cycle_tables(connection: Connection) -> None:
+    run_columns = _column_names(connection, "automation_runs")
+    required_columns = {
+        "cycle_key",
+        "slot_key",
+        "job_id",
+        "trigger",
+        "account_id",
+        "scheduled_for",
+        "cycle_window_end",
+        "created_at",
+    }
+    if not required_columns.issubset(run_columns):
+        return
+
+    observed_rows = connection.execute(
+        sa.text(
+            """
+            SELECT
+                automation_runs.cycle_key,
+                automation_runs.slot_key,
+                automation_runs.job_id,
+                automation_runs.trigger,
+                automation_jobs.include_paused_accounts,
+                automation_runs.account_id,
+                automation_runs.scheduled_for,
+                automation_runs.cycle_window_end,
+                automation_runs.created_at
+            FROM automation_runs
+            JOIN automation_jobs ON automation_jobs.id = automation_runs.job_id
+            WHERE automation_runs.cycle_key IS NOT NULL AND automation_runs.cycle_key != ''
+            ORDER BY automation_runs.created_at ASC, automation_runs.scheduled_for ASC, automation_runs.id ASC
+            """
+        )
+    ).mappings()
+    snapshots = _build_cycle_snapshots(
+        [
+            {
+                "cycle_key": _normalize_cycle_key(
+                    trigger=str(row["trigger"]),
+                    cycle_key=str(row["cycle_key"]),
+                    slot_key=str(row["slot_key"]),
+                ),
+                "job_id": str(row["job_id"]),
+                "trigger": str(row["trigger"]),
+                "include_paused_accounts": bool(row["include_paused_accounts"]),
+                "account_id": str(row["account_id"]) if row["account_id"] else None,
+                "scheduled_for": row["scheduled_for"],
+                "cycle_window_end": row["cycle_window_end"],
+                "created_at": row["created_at"],
+            }
+            for row in observed_rows
+        ]
+    )
+
+    existing_cycle_keys = set(
+        connection.execute(sa.text("SELECT cycle_key FROM automation_run_cycles")).scalars().all()
+    )
+    for snapshot in snapshots:
+        if snapshot["cycle_key"] in existing_cycle_keys:
+            continue
+        connection.execute(
+            sa.text(
+                """
+                INSERT INTO automation_run_cycles (
+                    cycle_key,
+                    job_id,
+                    trigger,
+                    cycle_expected_accounts,
+                    cycle_window_end,
+                    include_paused_accounts,
+                    created_at
+                ) VALUES (
+                    :cycle_key,
+                    :job_id,
+                    :trigger,
+                    :cycle_expected_accounts,
+                    :cycle_window_end,
+                    :include_paused_accounts,
+                    :created_at
+                )
+                """
+            ),
+            {
+                "cycle_key": snapshot["cycle_key"],
+                "job_id": snapshot["job_id"],
+                "trigger": snapshot["trigger"],
+                "cycle_expected_accounts": snapshot["cycle_expected_accounts"],
+                "cycle_window_end": snapshot["cycle_window_end"],
+                "include_paused_accounts": snapshot["include_paused_accounts"],
+                "created_at": snapshot["created_at"],
+            },
+        )
+        existing_cycle_keys.add(snapshot["cycle_key"])
+
+    existing_cycle_accounts = {
+        (cycle_key, account_id)
+        for cycle_key, account_id in connection.execute(
+            sa.text("SELECT cycle_key, account_id FROM automation_run_cycle_accounts")
+        ).all()
+    }
+    for snapshot in snapshots:
+        for position, (account_id, scheduled_for) in enumerate(snapshot["accounts"]):
+            account_key = (snapshot["cycle_key"], account_id)
+            if account_key in existing_cycle_accounts:
+                continue
+            connection.execute(
+                sa.text(
+                    """
+                    INSERT INTO automation_run_cycle_accounts (
+                        cycle_key,
+                        account_id,
+                        position,
+                        scheduled_for
+                    ) VALUES (
+                        :cycle_key,
+                        :account_id,
+                        :position,
+                        :scheduled_for
+                    )
+                    """
+                ),
+                {
+                    "cycle_key": snapshot["cycle_key"],
+                    "account_id": account_id,
+                    "position": position,
+                    "scheduled_for": scheduled_for,
+                },
+            )
+            existing_cycle_accounts.add(account_key)
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    if not _table_exists(bind, "automation_runs"):
+        return
+
+    _create_cycle_tables(bind)
+    _backfill_cycle_tables(bind)
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    if _table_exists(bind, "automation_run_cycle_accounts"):
+        op.drop_table("automation_run_cycle_accounts")
+    if _table_exists(bind, "automation_run_cycles"):
+        op.drop_table("automation_run_cycles")

app/db/alembic/versions/20260421_000000_add_dashboard_session_ttl_setting.py

@@ -0,0 +1,51 @@
+"""add dashboard session ttl setting
+
+Revision ID: 20260421_000000_add_dashboard_session_ttl_setting
+Revises: 20260417_000000_add_request_log_plan_type
+Create Date: 2026-04-21
+"""
+
+from __future__ import annotations
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.engine import Connection
+
+revision = "20260421_000000_add_dashboard_session_ttl_setting"
+down_revision = "20260417_000000_add_request_log_plan_type"
+branch_labels = None
+depends_on = None
+
+
+def _columns(connection: Connection, table_name: str) -> set[str]:
+    inspector = sa.inspect(connection)
+    if not inspector.has_table(table_name):
+        return set()
+    return {str(column["name"]) for column in inspector.get_columns(table_name) if column.get("name") is not None}
+
+
+def upgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "dashboard_settings")
+    if not columns or "dashboard_session_ttl_seconds" in columns:
+        return
+
+    with op.batch_alter_table("dashboard_settings") as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "dashboard_session_ttl_seconds",
+                sa.Integer(),
+                nullable=False,
+                server_default=sa.text("43200"),
+            )
+        )
+
+
+def downgrade() -> None:
+    bind = op.get_bind()
+    columns = _columns(bind, "dashboard_settings")
+    if not columns or "dashboard_session_ttl_seconds" not in columns:
+        return
+
+    with op.batch_alter_table("dashboard_settings") as batch_op:
+        batch_op.drop_column("dashboard_session_ttl_seconds")

app/db/alembic/versions/20260421_120000_merge_request_log_lookup_and_plan_type_heads.py

@@ -0,0 +1,25 @@
+"""merge request log lookup and plan type heads
+
+Revision ID: 20260421_120000_merge_request_log_lookup_and_plan_type_heads
+Revises: 20260415_160000_add_request_logs_response_lookup_index,
+20260417_000000_add_request_log_plan_type
+Create Date: 2026-04-21
+"""
+
+from __future__ import annotations
+
+revision = "20260421_120000_merge_request_log_lookup_and_plan_type_heads"
+down_revision = (
+    "20260415_160000_add_request_logs_response_lookup_index",
+    "20260417_000000_add_request_log_plan_type",
+)
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    return
+
+
+def downgrade() -> None:
+    return