langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/__init__.py

@@ -0,0 +1,215 @@
+"""Langflow backwards compatibility layer.
+
+This module provides backwards compatibility by forwarding imports from
+langflow.* to lfx.* to maintain compatibility with existing code that
+references the old langflow module structure.
+"""
+
+import importlib
+import importlib.util
+import sys
+from types import ModuleType
+from typing import Any
+
+
+class LangflowCompatibilityModule(ModuleType):
+    """A module that forwards attribute access to the corresponding lfx module."""
+
+    def __init__(self, name: str, lfx_module_name: str):
+        super().__init__(name)
+        self._lfx_module_name = lfx_module_name
+        self._lfx_module = None
+
+    def _get_lfx_module(self):
+        """Lazily import and cache the lfx module."""
+        if self._lfx_module is None:
+            try:
+                self._lfx_module = importlib.import_module(self._lfx_module_name)
+            except ImportError as e:
+                msg = f"Cannot import {self._lfx_module_name} for backwards compatibility with {self.__name__}"
+                raise ImportError(msg) from e
+        return self._lfx_module
+
+    def __getattr__(self, name: str) -> Any:
+        """Forward attribute access to the lfx module with caching."""
+        lfx_module = self._get_lfx_module()
+        try:
+            attr = getattr(lfx_module, name)
+        except AttributeError as e:
+            msg = f"module '{self.__name__}' has no attribute '{name}'"
+            raise AttributeError(msg) from e
+        else:
+            # Cache the attribute in our __dict__ for faster subsequent access
+            setattr(self, name, attr)
+            return attr
+
+    def __dir__(self):
+        """Return directory of the lfx module."""
+        try:
+            lfx_module = self._get_lfx_module()
+            return dir(lfx_module)
+        except ImportError:
+            return []
+
+
+def _setup_compatibility_modules():
+    """Set up comprehensive compatibility modules for langflow.base imports."""
+    # First, set up the base attribute on this module (langflow)
+    current_module = sys.modules[__name__]
+
+    # Define all the modules we need to support
+    module_mappings = {
+        # Core base module
+        "langflow.base": "lfx.base",
+        # Inputs module - critical for class identity
+        "langflow.inputs": "lfx.inputs",
+        "langflow.inputs.inputs": "lfx.inputs.inputs",
+        # Schema modules - also critical for class identity
+        "langflow.schema": "lfx.schema",
+        "langflow.schema.data": "lfx.schema.data",
+        "langflow.schema.serialize": "lfx.schema.serialize",
+        # Template modules
+        "langflow.template": "lfx.template",
+        "langflow.template.field": "lfx.template.field",
+        "langflow.template.field.base": "lfx.template.field.base",
+        # Components modules
+        "langflow.components": "lfx.components",
+        "langflow.components.helpers": "lfx.components.helpers",
+        "langflow.components.helpers.calculator_core": "lfx.components.helpers.calculator_core",
+        "langflow.components.helpers.create_list": "lfx.components.helpers.create_list",
+        "langflow.components.helpers.current_date": "lfx.components.helpers.current_date",
+        "langflow.components.helpers.id_generator": "lfx.components.helpers.id_generator",
+        "langflow.components.helpers.memory": "lfx.components.helpers.memory",
+        "langflow.components.helpers.output_parser": "lfx.components.helpers.output_parser",
+        "langflow.components.helpers.store_message": "lfx.components.helpers.store_message",
+        # Individual modules that exist in lfx
+        "langflow.base.agents": "lfx.base.agents",
+        "langflow.base.chains": "lfx.base.chains",
+        "langflow.base.data": "lfx.base.data",
+        "langflow.base.data.utils": "lfx.base.data.utils",
+        "langflow.base.document_transformers": "lfx.base.document_transformers",
+        "langflow.base.embeddings": "lfx.base.embeddings",
+        "langflow.base.flow_processing": "lfx.base.flow_processing",
+        "langflow.base.io": "lfx.base.io",
+        "langflow.base.io.chat": "lfx.base.io.chat",
+        "langflow.base.io.text": "lfx.base.io.text",
+        "langflow.base.langchain_utilities": "lfx.base.langchain_utilities",
+        "langflow.base.memory": "lfx.base.memory",
+        "langflow.base.models": "lfx.base.models",
+        "langflow.base.models.google_generative_ai_constants": "lfx.base.models.google_generative_ai_constants",
+        "langflow.base.models.openai_constants": "lfx.base.models.openai_constants",
+        "langflow.base.models.anthropic_constants": "lfx.base.models.anthropic_constants",
+        "langflow.base.models.aiml_constants": "lfx.base.models.aiml_constants",
+        "langflow.base.models.aws_constants": "lfx.base.models.aws_constants",
+        "langflow.base.models.groq_constants": "lfx.base.models.groq_constants",
+        "langflow.base.models.novita_constants": "lfx.base.models.novita_constants",
+        "langflow.base.models.ollama_constants": "lfx.base.models.ollama_constants",
+        "langflow.base.models.sambanova_constants": "lfx.base.models.sambanova_constants",
+        "langflow.base.prompts": "lfx.base.prompts",
+        "langflow.base.prompts.api_utils": "lfx.base.prompts.api_utils",
+        "langflow.base.prompts.utils": "lfx.base.prompts.utils",
+        "langflow.base.textsplitters": "lfx.base.textsplitters",
+        "langflow.base.tools": "lfx.base.tools",
+        "langflow.base.vectorstores": "lfx.base.vectorstores",
+    }
+
+    # Create compatibility modules for each mapping
+    for langflow_name, lfx_name in module_mappings.items():
+        if langflow_name not in sys.modules:
+            # Check if the lfx module exists
+            try:
+                spec = importlib.util.find_spec(lfx_name)
+                if spec is not None:
+                    # Create compatibility module
+                    compat_module = LangflowCompatibilityModule(langflow_name, lfx_name)
+                    sys.modules[langflow_name] = compat_module
+
+                    # Set up the module hierarchy
+                    parts = langflow_name.split(".")
+                    if len(parts) > 1:
+                        parent_name = ".".join(parts[:-1])
+                        parent_module = sys.modules.get(parent_name)
+                        if parent_module is not None:
+                            setattr(parent_module, parts[-1], compat_module)
+
+                    # Special handling for top-level modules
+                    if langflow_name == "langflow.base":
+                        current_module.base = compat_module
+                    elif langflow_name == "langflow.inputs":
+                        current_module.inputs = compat_module
+                    elif langflow_name == "langflow.schema":
+                        current_module.schema = compat_module
+                    elif langflow_name == "langflow.template":
+                        current_module.template = compat_module
+                    elif langflow_name == "langflow.components":
+                        current_module.components = compat_module
+            except (ImportError, ValueError):
+                # Skip modules that don't exist in lfx
+                continue
+
+    # Handle modules that exist only in langflow (like knowledge_bases)
+    # These need special handling because they're not in lfx yet
+    langflow_only_modules = {
+        "langflow.base.data.kb_utils": "langflow.base.data.kb_utils",
+        "langflow.base.knowledge_bases": "langflow.base.knowledge_bases",
+        "langflow.components.knowledge_bases": "langflow.components.knowledge_bases",
+    }
+
+    for langflow_name in langflow_only_modules:
+        if langflow_name not in sys.modules:
+            try:
+                # Try to find the actual physical module file
+                from pathlib import Path
+
+                base_dir = Path(__file__).parent
+
+                if langflow_name == "langflow.base.data.kb_utils":
+                    kb_utils_file = base_dir / "base" / "data" / "kb_utils.py"
+                    if kb_utils_file.exists():
+                        spec = importlib.util.spec_from_file_location(langflow_name, kb_utils_file)
+                        if spec is not None and spec.loader is not None:
+                            module = importlib.util.module_from_spec(spec)
+                            sys.modules[langflow_name] = module
+                            spec.loader.exec_module(module)
+
+                            # Also add to parent module
+                            parent_module = sys.modules.get("langflow.base.data")
+                            if parent_module is not None:
+                                parent_module.kb_utils = module
+
+                elif langflow_name == "langflow.base.knowledge_bases":
+                    kb_dir = base_dir / "base" / "knowledge_bases"
+                    kb_init_file = kb_dir / "__init__.py"
+                    if kb_init_file.exists():
+                        spec = importlib.util.spec_from_file_location(langflow_name, kb_init_file)
+                        if spec is not None and spec.loader is not None:
+                            module = importlib.util.module_from_spec(spec)
+                            sys.modules[langflow_name] = module
+                            spec.loader.exec_module(module)
+
+                            # Also add to parent module
+                            parent_module = sys.modules.get("langflow.base")
+                            if parent_module is not None:
+                                parent_module.knowledge_bases = module
+
+                elif langflow_name == "langflow.components.knowledge_bases":
+                    components_kb_dir = base_dir / "components" / "knowledge_bases"
+                    components_kb_init_file = components_kb_dir / "__init__.py"
+                    if components_kb_init_file.exists():
+                        spec = importlib.util.spec_from_file_location(langflow_name, components_kb_init_file)
+                        if spec is not None and spec.loader is not None:
+                            module = importlib.util.module_from_spec(spec)
+                            sys.modules[langflow_name] = module
+                            spec.loader.exec_module(module)
+
+                            # Also add to parent module
+                            parent_module = sys.modules.get("langflow.components")
+                            if parent_module is not None:
+                                parent_module.knowledge_bases = module
+            except (ImportError, AttributeError):
+                # If direct file loading fails, skip silently
+                continue
+
+
+# Set up all the compatibility modules
+_setup_compatibility_modules()

langflow/__main__.py

@@ -18,6 +18,8 @@ from dotenv import load_dotenv
 from fastapi import HTTPException
 from httpx import HTTPError
 from jose import JWTError
+from lfx.log.logger import configure, logger
+from lfx.services.settings.constants import DEFAULT_SUPERUSER, DEFAULT_SUPERUSER_PASSWORD
 from multiprocess import cpu_count
 from multiprocess.context import Process
 from packaging import version as pkg_version
@@ -29,11 +31,9 @@ from sqlmodel import select
 
 from langflow.cli.progress import create_langflow_progress
 from langflow.initial_setup.setup import get_or_create_default_folder
-from langflow.logging.logger import configure, logger
 from langflow.main import setup_app
 from langflow.services.auth.utils import check_key, get_current_user_by_jwt
 from langflow.services.deps import get_db_service, get_settings_service, session_scope
-from langflow.services.settings.constants import DEFAULT_SUPERUSER, DEFAULT_SUPERUSER_PASSWORD
 from langflow.services.utils import initialize_services
 from langflow.utils.version import fetch_latest_version, get_version_info
 from langflow.utils.version import is_pre_release as langflow_is_pre_release
@@ -43,6 +43,20 @@ console = Console(legacy_windows=True, emoji=False) if platform.system() == "Win
 
 app = typer.Typer(no_args_is_help=True)
 
+# Add LFX commands as a sub-app
+try:
+    from lfx.cli.commands import serve_command
+    from lfx.cli.run import run as lfx_run
+
+    lfx_app = typer.Typer(name="lfx", help="Langflow Executor commands")
+    lfx_app.command(name="serve", help="Serve a flow as an API", no_args_is_help=True)(serve_command)
+    lfx_app.command(name="run", help="Run a flow directly", no_args_is_help=True)(lfx_run)
+
+    app.add_typer(lfx_app, name="lfx")
+except ImportError:
+    # LFX not available, skip adding the sub-app
+    pass
+
 
 class ProcessManager:
     """Manages the lifecycle of the backend process."""

langflow/alembic/versions/006b3990db50_add_unique_constraints.py

@@ -6,17 +6,16 @@ Create Date: 2023-12-13 18:55:52.587360
 
 """
 
-from typing import Sequence, Union
+from collections.abc import Sequence
 
 import sqlalchemy as sa
 from alembic import op
-from sqlalchemy.engine.reflection import Inspector
 
 # revision identifiers, used by Alembic.
 revision: str = "006b3990db50"
-down_revision: Union[str, None] = "1ef9c4f3765d"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
+down_revision: str | None = "1ef9c4f3765d"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
 
 
 def upgrade() -> None:
@@ -38,7 +37,6 @@ def upgrade() -> None:
                 batch_op.create_unique_constraint("uq_user_id", ["id"])
     except Exception as e:
         print(e)
-        pass
 
     # ### end Alembic commands ###
 
@@ -62,5 +60,4 @@ def downgrade() -> None:
                 batch_op.drop_constraint("uq_apikey_id", type_="unique")
     except Exception as e:
         print(e)
-        pass
     # ### end Alembic commands ###

langflow/alembic/versions/012fb73ac359_add_folder_table.py

@@ -6,18 +6,17 @@ Create Date: 2024-05-07 12:52:16.954691
 
 """
 
-from typing import Sequence, Union
+from collections.abc import Sequence
 
 import sqlalchemy as sa
 import sqlmodel
 from alembic import op
-from sqlalchemy.engine.reflection import Inspector
 
 # revision identifiers, used by Alembic.
 revision: str = "012fb73ac359"
-down_revision: Union[str, None] = "c153816fd85f"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
+down_revision: str | None = "c153816fd85f"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
 
 
 def upgrade() -> None:

langflow/alembic/versions/0ae3a2674f32_update_the_columns_that_need_to_change_.py

@@ -5,21 +5,20 @@ Revises: d2d475a1f7c0
 Create Date: 2024-10-04 17:30:12.924809
 
 """
-from typing import Sequence, Union
+
+from collections.abc import Sequence
 
 import sqlalchemy as sa
-import sqlmodel
 from alembic import op
-from sqlalchemy.dialects import sqlite
-from sqlalchemy.engine.reflection import Inspector
 
 from langflow.utils import migration
 
 # revision identifiers, used by Alembic.
-revision: str = '0ae3a2674f32'
-down_revision: Union[str, None] = 'd2d475a1f7c0'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
+revision: str = "0ae3a2674f32"
+down_revision: str | None = "d2d475a1f7c0"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
 
 def upgrade() -> None:
     conn = op.get_bind()
@@ -31,18 +30,14 @@ def upgrade() -> None:
             columns = inspector.get_columns("vertex_build")
             params_column = next((column for column in columns if column["name"] == "params"), None)
             if params_column is not None and isinstance(params_column["type"], sa.VARCHAR):
-                batch_op.alter_column(
-                    "params", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True
-                )
+                batch_op.alter_column("params", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True)
 
     with op.batch_alter_table("message", schema=None) as batch_op:
         if migration.column_exists(table_name="message", column_name="text", conn=conn):
             columns = inspector.get_columns("message")
             text_column = next((column for column in columns if column["name"] == "text"), None)
             if text_column is not None and isinstance(text_column["type"], sa.VARCHAR):
-                batch_op.alter_column(
-                    "text", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True
-                )
+                batch_op.alter_column("text", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True)
 
     # ### end Alembic commands ###
 
@@ -56,16 +51,12 @@ def downgrade() -> None:
             columns = inspector.get_columns("message")
             text_column = next((column for column in columns if column["name"] == "text"), None)
             if text_column is not None and isinstance(text_column["type"], sa.VARCHAR):
-                batch_op.alter_column(
-                    "text", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True
-                )
+                batch_op.alter_column("text", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True)
 
     with op.batch_alter_table("vertex_build", schema=None) as batch_op:
         if migration.column_exists(table_name="vertex_build", column_name="params", conn=conn):
             columns = inspector.get_columns("vertex_build")
             params_column = next((column for column in columns if column["name"] == "params"), None)
             if params_column is not None and isinstance(params_column["type"], sa.VARCHAR):
-                batch_op.alter_column(
-                    "params", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True
-                )
+                batch_op.alter_column("params", existing_type=sa.VARCHAR(), type_=sa.Text(), existing_nullable=True)
     # ### end Alembic commands ###

langflow/alembic/versions/0b8757876a7c_.py

@@ -6,16 +6,13 @@ Create Date: 2024-01-17 10:32:56.686287
 
 """
 
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-from alembic import op
+from collections.abc import Sequence
 
 # revision identifiers, used by Alembic.
 revision: str = "0b8757876a7c"
-down_revision: Union[str, None] = "006b3990db50"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
+down_revision: str | None = "006b3990db50"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
 
 
 def upgrade() -> None:

langflow/alembic/versions/0d60fcbd4e8e_create_vertex_builds_table.py

@@ -6,7 +6,7 @@ Create Date: 2024-07-26 11:41:31.274271
 
 """
 
-from typing import Sequence, Union
+from collections.abc import Sequence
 
 import sqlalchemy as sa
 import sqlmodel
@@ -16,9 +16,9 @@ from langflow.utils import migration
 
 # revision identifiers, used by Alembic.
 revision: str = "0d60fcbd4e8e"
-down_revision: Union[str, None] = "90be8e2ed91e"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
+down_revision: str | None = "90be8e2ed91e"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
 
 
 def upgrade() -> None:
@@ -41,11 +41,9 @@ def upgrade() -> None:
             ),
             sa.PrimaryKeyConstraint("build_id"),
         )
-    pass
 
 
 def downgrade() -> None:
     conn = op.get_bind()
     if migration.table_exists("vertex_build", conn):
         op.drop_table("vertex_build")
-    pass

langflow/alembic/versions/1a110b568907_replace_credential_table_with_variable.py

@@ -6,18 +6,17 @@ Create Date: 2024-03-25 09:40:02.743453
 
 """
 
-from typing import Sequence, Union
+from collections.abc import Sequence
 
 import sqlalchemy as sa
 import sqlmodel
 from alembic import op
-from sqlalchemy.engine.reflection import Inspector
 
 # revision identifiers, used by Alembic.
 revision: str = "1a110b568907"
-down_revision: Union[str, None] = "63b9c451fd30"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
+down_revision: str | None = "63b9c451fd30"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
 
 
 def upgrade() -> None:

langflow/alembic/versions/1b8b740a6fa3_remove_fk_constraint_in_message_.py

@@ -1,25 +1,25 @@
 """remove fk constraint in message transaction and vertex build
 
-
 Revision ID: 1b8b740a6fa3
 Revises: f3b2d1f1002d
 Create Date: 2025-04-10 10:17:32.493181
 
 """
-from typing import Sequence, Union
 
-from alembic import op
+from collections.abc import Sequence
+
 import sqlalchemy as sa
 import sqlmodel
+from alembic import op
 from sqlalchemy.engine.reflection import Inspector
-from langflow.utils import migration
 
+from langflow.utils import migration
 
 # revision identifiers, used by Alembic.
-revision: str = '1b8b740a6fa3'
-down_revision: Union[str, None] = 'f3b2d1f1002d'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
+revision: str = "1b8b740a6fa3"
+down_revision: str | None = "f3b2d1f1002d"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
 
 NAMING_CONVENTION = {
     "ix": "ix_%(column_0_label)s",
@@ -29,6 +29,7 @@ NAMING_CONVENTION = {
     "pk": "pk_%(table_name)s",
 }
 
+
 def constraint_exists(constraint_name: str, conn) -> bool:
     """Check if a constraint with the given name already exists in the database.
 
@@ -46,12 +47,16 @@ def constraint_exists(constraint_name: str, conn) -> bool:
 
     # Check each table for the constraint
     for table in tables:
-        for constraint in inspector.get_pk_constraint(table).get("name"), *[c.get("name") for c in inspector.get_foreign_keys(table)]:
+        for constraint in (
+            inspector.get_pk_constraint(table).get("name"),
+            *[c.get("name") for c in inspector.get_foreign_keys(table)],
+        ):
             if constraint == constraint_name:
                 return True
 
     return False
 
+
 def upgrade() -> None:
     conn = op.get_bind()
 
@@ -67,7 +72,7 @@ def upgrade() -> None:
         # Check if PK constraint already exists
         if constraint_exists(pk_name, conn):
             # Use a different PK name if it already exists
-            pk_name = f"pk_temp_vertex_build"
+            pk_name = "pk_temp_vertex_build"
 
         # Create temp table with same schema but no FK constraint
         op.create_table(
@@ -85,7 +90,7 @@ def upgrade() -> None:
 
         # Copy data - use a window function to ensure build_id uniqueness across SQLite, PostgreSQL and MySQL
         # Filter out rows where the original 'id' (vertex id) is NULL, as the new table requires it.
-        op.execute(f'''
+        op.execute(f"""
             INSERT INTO "{temp_table_name}" (timestamp, id, data, artifacts, params, build_id, flow_id, valid)
             SELECT timestamp, id, data, artifacts, params, build_id, flow_id, valid
             FROM (
@@ -95,7 +100,7 @@ def upgrade() -> None:
                 WHERE id IS NOT NULL -- Ensure vertex id is not NULL
             ) sub
             WHERE rn = 1
-        ''')
+        """)
 
         # Drop original table and rename temp table
         op.drop_table("vertex_build")
@@ -110,7 +115,7 @@ def upgrade() -> None:
         # Check if PK constraint already exists
         if constraint_exists(pk_name, conn):
             # Use a different PK name if it already exists
-            pk_name = f"pk_temp_transaction"
+            pk_name = "pk_temp_transaction"
 
         # Create temp table with same schema but no FK constraint
         op.create_table(
@@ -128,12 +133,12 @@ def upgrade() -> None:
         )
 
         # Copy data - explicitly list columns and filter out rows where id is NULL
-        op.execute(f'''
+        op.execute(f"""
             INSERT INTO "{temp_table_name}" (timestamp, vertex_id, target_id, inputs, outputs, status, id, flow_id, error)
             SELECT timestamp, vertex_id, target_id, inputs, outputs, status, id, flow_id, error
             FROM "transaction"
             WHERE id IS NOT NULL
-        ''')
+        """)
 
         # Drop original table and rename temp table
         op.drop_table("transaction")
@@ -148,7 +153,7 @@ def upgrade() -> None:
         # Check if PK constraint already exists
         if constraint_exists(pk_name, conn):
             # Use a different PK name if it already exists
-            pk_name = f"pk_temp_message"
+            pk_name = "pk_temp_message"
 
         # Create temp table with same schema but no FK constraint
         op.create_table(
@@ -170,12 +175,12 @@ def upgrade() -> None:
         )
 
         # Copy data - explicitly list columns and filter out rows where id is NULL
-        op.execute(f'''
+        op.execute(f"""
             INSERT INTO "{temp_table_name}" (timestamp, sender, sender_name, session_id, text, id, flow_id, files, error, edit, properties, category, content_blocks)
             SELECT timestamp, sender, sender_name, session_id, text, id, flow_id, files, error, edit, properties, category, content_blocks
             FROM "message"
             WHERE id IS NOT NULL
-        ''')
+        """)
 
         # Drop original table and rename temp table
         op.drop_table("message")
@@ -196,7 +201,7 @@ def downgrade() -> None:
 
         # Check if constraints already exist
         if constraint_exists(pk_name, conn):
-            pk_name = f"pk_temp_vertex_build"
+            pk_name = "pk_temp_vertex_build"
 
         if constraint_exists(fk_name, conn):
             fk_name = f"fk_vertex_build_flow_id_flow_{revision[:8]}"
@@ -223,7 +228,7 @@ def downgrade() -> None:
         # Copy data - use a window function to ensure build_id uniqueness.
         # Filter out rows where build_id is NULL (PK constraint)
         # No need to filter by 'id' here as the target column allows NULLs.
-        op.execute(f'''
+        op.execute(f"""
             INSERT INTO "{temp_table_name}" (timestamp, id, data, artifacts, params, build_id, flow_id, valid)
             SELECT timestamp, id, data, artifacts, params, build_id, flow_id, valid
             FROM (
@@ -233,7 +238,7 @@ def downgrade() -> None:
                 WHERE build_id IS NOT NULL -- Ensure primary key is not NULL
             ) sub
             WHERE rn = 1
-        ''')
+        """)
 
         # Drop original table and rename temp table
         op.drop_table("vertex_build")
@@ -248,7 +253,7 @@ def downgrade() -> None:
 
         # Check if constraints already exist
         if constraint_exists(pk_name, conn):
-            pk_name = f"pk_temp_transaction"
+            pk_name = "pk_temp_transaction"
 
         if constraint_exists(fk_name, conn):
             fk_name = f"fk_transaction_flow_id_flow_{revision[:8]}"
@@ -274,12 +279,12 @@ def downgrade() -> None:
         )
 
         # Copy data - explicitly list columns and filter out rows where id is NULL
-        op.execute(f'''
+        op.execute(f"""
             INSERT INTO "{temp_table_name}" (timestamp, vertex_id, target_id, inputs, outputs, status, id, flow_id, error)
             SELECT timestamp, vertex_id, target_id, inputs, outputs, status, id, flow_id, error
             FROM "transaction"
             WHERE id IS NOT NULL
-        ''')
+        """)
 
         # Drop original table and rename temp table
         op.drop_table("transaction")
@@ -294,7 +299,7 @@ def downgrade() -> None:
 
         # Check if constraints already exist
         if constraint_exists(pk_name, conn):
-            pk_name = f"pk_temp_message"
+            pk_name = "pk_temp_message"
 
         if constraint_exists(fk_name, conn):
             fk_name = f"fk_message_flow_id_flow_{revision[:8]}"
@@ -324,12 +329,12 @@ def downgrade() -> None:
         )
 
         # Copy data - explicitly list columns and filter out rows where id is NULL
-        op.execute(f'''
+        op.execute(f"""
             INSERT INTO "{temp_table_name}" (timestamp, sender, sender_name, session_id, text, id, flow_id, files, error, edit, properties, category, content_blocks)
             SELECT timestamp, sender, sender_name, session_id, text, id, flow_id, files, error, edit, properties, category, content_blocks
             FROM "message"
             WHERE id IS NOT NULL
-        ''')
+        """)
 
         # Drop original table and rename temp table
         op.drop_table("message")