alembic 1.14.1__py3-none-any.whl → 1.15.0__py3-none-any.whl

alembic/__init__.py

@@ -1,4 +1,4 @@
 from . import context
 from . import op
 
-__version__ = "1.14.1"
+__version__ = "1.15.0"

alembic/autogenerate/compare.py

@@ -216,7 +216,7 @@ def _compare_tables(
                 (inspector),
                 # fmt: on
             )
-            sqla_compat._reflect_table(inspector, t)
+            inspector.reflect_table(t, include_columns=None)
         if autogen_context.run_object_filters(t, tname, "table", True, None):
             modify_table_ops = ops.ModifyTableOps(tname, [], schema=s)
 
@@ -246,7 +246,7 @@ def _compare_tables(
                 _compat_autogen_column_reflect(inspector),
                 # fmt: on
             )
-            sqla_compat._reflect_table(inspector, t)
+            inspector.reflect_table(t, include_columns=None)
         conn_column_info[(s, tname)] = t
 
     for s, tname in sorted(existing_tables, key=lambda x: (x[0] or "", x[1])):
@@ -1067,27 +1067,15 @@ def _compare_server_default(
         return False
 
     if sqla_compat._server_default_is_computed(metadata_default):
-        # return False in case of a computed column as the server
-        # default. Note that DDL for adding or removing "GENERATED AS" from
-        # an existing column is not currently known for any backend.
-        # Once SQLAlchemy can reflect "GENERATED" as the "computed" element,
-        # we would also want to ignore and/or warn for changes vs. the
-        # metadata (or support backend specific DDL if applicable).
-        if not sqla_compat.has_computed_reflection:
-            return False
-
-        else:
-            return (
-                _compare_computed_default(  # type:ignore[func-returns-value]
-                    autogen_context,
-                    alter_column_op,
-                    schema,
-                    tname,
-                    cname,
-                    conn_col,
-                    metadata_col,
-                )
-            )
+        return _compare_computed_default(  # type:ignore[func-returns-value]
+            autogen_context,
+            alter_column_op,
+            schema,
+            tname,
+            cname,
+            conn_col,
+            metadata_col,
+        )
     if sqla_compat._server_default_is_computed(conn_col_default):
         _warn_computed_not_supported(tname, cname)
         return False

alembic/autogenerate/render.py

@@ -19,6 +19,7 @@ from sqlalchemy import schema as sa_schema
 from sqlalchemy import sql
 from sqlalchemy import types as sqltypes
 from sqlalchemy.sql.elements import conv
+from sqlalchemy.sql.elements import Label
 from sqlalchemy.sql.elements import quoted_name
 
 from .. import util
@@ -28,6 +29,8 @@ from ..util import sqla_compat
 if TYPE_CHECKING:
     from typing import Literal
 
+    from sqlalchemy import Computed
+    from sqlalchemy import Identity
     from sqlalchemy.sql.base import DialectKWArgs
     from sqlalchemy.sql.elements import ColumnElement
     from sqlalchemy.sql.elements import TextClause
@@ -48,8 +51,6 @@ if TYPE_CHECKING:
     from alembic.config import Config
     from alembic.operations.ops import MigrationScript
     from alembic.operations.ops import ModifyTableOps
-    from alembic.util.sqla_compat import Computed
-    from alembic.util.sqla_compat import Identity
 
 
 MAX_PYTHON_ARGS = 255
@@ -584,23 +585,28 @@ def _render_potential_expr(
     value: Any,
     autogen_context: AutogenContext,
     *,
-    wrap_in_text: bool = True,
+    wrap_in_element: bool = True,
     is_server_default: bool = False,
     is_index: bool = False,
 ) -> str:
     if isinstance(value, sql.ClauseElement):
-        if wrap_in_text:
-            template = "%(prefix)stext(%(sql)r)"
+        sql_text = autogen_context.migration_context.impl.render_ddl_sql_expr(
+            value, is_server_default=is_server_default, is_index=is_index
+        )
+        if wrap_in_element:
+            prefix = _sqlalchemy_autogenerate_prefix(autogen_context)
+            element = "literal_column" if is_index else "text"
+            value_str = f"{prefix}{element}({sql_text!r})"
+            if (
+                is_index
+                and isinstance(value, Label)
+                and type(value.name) is str
+            ):
+                return value_str + f".label({value.name!r})"
+            else:
+                return value_str
         else:
-            template = "%(sql)r"
-
-        return template % {
-            "prefix": _sqlalchemy_autogenerate_prefix(autogen_context),
-            "sql": autogen_context.migration_context.impl.render_ddl_sql_expr(
-                value, is_server_default=is_server_default, is_index=is_index
-            ),
-        }
-
+            return repr(sql_text)
     else:
         return repr(value)
 
@@ -628,9 +634,9 @@ def _uq_constraint(
     has_batch = autogen_context._has_batch
 
     if constraint.deferrable:
-        opts.append(("deferrable", str(constraint.deferrable)))
+        opts.append(("deferrable", constraint.deferrable))
     if constraint.initially:
-        opts.append(("initially", str(constraint.initially)))
+        opts.append(("initially", constraint.initially))
     if not has_batch and alter and constraint.table.schema:
         opts.append(("schema", _ident(constraint.table.schema)))
     if not alter and constraint.name:
@@ -741,7 +747,7 @@ def _render_column(
                 + [
                     "%s=%s"
                     % (key, _render_potential_expr(val, autogen_context))
-                    for key, val in sqla_compat._column_kwargs(column).items()
+                    for key, val in column.kwargs.items()
                 ]
             )
         ),
@@ -787,7 +793,7 @@ def _render_computed(
     computed: Computed, autogen_context: AutogenContext
 ) -> str:
     text = _render_potential_expr(
-        computed.sqltext, autogen_context, wrap_in_text=False
+        computed.sqltext, autogen_context, wrap_in_element=False
     )
 
     kwargs = {}
@@ -1101,7 +1107,7 @@ def _render_check_constraint(
             else ""
         ),
         "sqltext": _render_potential_expr(
-            constraint.sqltext, autogen_context, wrap_in_text=False
+            constraint.sqltext, autogen_context, wrap_in_element=False
         ),
     }
 

alembic/command.py

@@ -298,7 +298,9 @@ def check(config: "Config") -> None:
 
     if diffs:
         raise util.AutogenerateDiffsDetected(
-            f"New upgrade operations detected: {diffs}"
+            f"New upgrade operations detected: {diffs}",
+            revision_context=revision_context,
+            diffs=diffs,
         )
     else:
         config.print_stdout("No new upgrade operations detected.")

alembic/context.pyi

@@ -5,7 +5,6 @@ from __future__ import annotations
 from typing import Any
 from typing import Callable
 from typing import Collection
-from typing import ContextManager
 from typing import Dict
 from typing import Iterable
 from typing import List
@@ -20,6 +19,8 @@ from typing import Tuple
 from typing import TYPE_CHECKING
 from typing import Union
 
+from typing_extensions import ContextManager
+
 if TYPE_CHECKING:
     from sqlalchemy.engine.base import Connection
     from sqlalchemy.engine.url import URL
@@ -40,7 +41,9 @@ if TYPE_CHECKING:
 
 ### end imports ###
 
-def begin_transaction() -> Union[_ProxyTransaction, ContextManager[None]]:
+def begin_transaction() -> (
+    Union[_ProxyTransaction, ContextManager[None, Optional[bool]]]
+):
     """Return a context manager that will
     enclose an operation within a "transaction",
     as defined by the environment's offline

alembic/ddl/base.py

@@ -25,6 +25,8 @@ from ..util.sqla_compat import _table_for_constraint  # noqa
 if TYPE_CHECKING:
     from typing import Any
 
+    from sqlalchemy import Computed
+    from sqlalchemy import Identity
     from sqlalchemy.sql.compiler import Compiled
     from sqlalchemy.sql.compiler import DDLCompiler
     from sqlalchemy.sql.elements import TextClause
@@ -33,8 +35,6 @@ if TYPE_CHECKING:
     from sqlalchemy.sql.type_api import TypeEngine
 
     from .impl import DefaultImpl
-    from ..util.sqla_compat import Computed
-    from ..util.sqla_compat import Identity
 
 _ServerDefault = Union["TextClause", "FetchedValue", "Function[Any]", str]
 

alembic/ddl/impl.py

@@ -459,7 +459,9 @@ class DefaultImpl(metaclass=ImplMeta):
         if self.as_sql:
             for row in rows:
                 self._exec(
-                    sqla_compat._insert_inline(table).values(
+                    table.insert()
+                    .inline()
+                    .values(
                         **{
                             k: (
                                 sqla_compat._literal_bindparam(
@@ -477,14 +479,10 @@ class DefaultImpl(metaclass=ImplMeta):
         else:
             if rows:
                 if multiinsert:
-                    self._exec(
-                        sqla_compat._insert_inline(table), multiparams=rows
-                    )
+                    self._exec(table.insert().inline(), multiparams=rows)
                 else:
                     for row in rows:
-                        self._exec(
-                            sqla_compat._insert_inline(table).values(**row)
-                        )
+                        self._exec(table.insert().inline().values(**row))
 
     def _tokenize_column_type(self, column: Column) -> Params:
         definition: str
@@ -693,7 +691,7 @@ class DefaultImpl(metaclass=ImplMeta):
         diff, ignored = _compare_identity_options(
             metadata_identity,
             inspector_identity,
-            sqla_compat.Identity(),
+            schema.Identity(),
             skip={"always"},
         )
 
@@ -874,12 +872,13 @@ def _compare_identity_options(
         set(meta_d).union(insp_d),
     )
     if sqla_compat.identity_has_dialect_kwargs:
+        assert hasattr(default_io, "dialect_kwargs")
         # use only the dialect kwargs in inspector_io since metadata_io
         # can have options for many backends
         check_dicts(
             getattr(metadata_io, "dialect_kwargs", {}),
             getattr(inspector_io, "dialect_kwargs", {}),
-            default_io.dialect_kwargs,  # type: ignore[union-attr]
+            default_io.dialect_kwargs,
             getattr(inspector_io, "dialect_kwargs", {}),
         )
 

alembic/ddl/mysql.py

@@ -23,7 +23,6 @@ from .base import format_server_default
 from .impl import DefaultImpl
 from .. import util
 from ..util import sqla_compat
-from ..util.sqla_compat import _is_mariadb
 from ..util.sqla_compat import _is_type_bound
 from ..util.sqla_compat import compiles
 
@@ -475,7 +474,7 @@ def _mysql_drop_constraint(
         # note that SQLAlchemy as of 1.2 does not yet support
         # DROP CONSTRAINT for MySQL/MariaDB, so we implement fully
         # here.
-        if _is_mariadb(compiler.dialect):
+        if compiler.dialect.is_mariadb:  # type: ignore[attr-defined]
             return "ALTER TABLE %s DROP CONSTRAINT %s" % (
                 compiler.preparer.format_table(constraint.table),
                 compiler.preparer.format_constraint(constraint),

alembic/ddl/postgresql.py

@@ -17,8 +17,10 @@ from typing import Union
 
 from sqlalchemy import Column
 from sqlalchemy import Float
+from sqlalchemy import Identity
 from sqlalchemy import literal_column
 from sqlalchemy import Numeric
+from sqlalchemy import select
 from sqlalchemy import text
 from sqlalchemy import types as sqltypes
 from sqlalchemy.dialects.postgresql import BIGINT
@@ -143,9 +145,7 @@ class PostgresqlImpl(DefaultImpl):
         conn = self.connection
         assert conn is not None
         return not conn.scalar(
-            sqla_compat._select(
-                literal_column(conn_col_default) == metadata_default
-            )
+            select(literal_column(conn_col_default) == metadata_default)
         )
 
     def alter_column(  # type:ignore[override]
@@ -586,7 +586,7 @@ def visit_identity_column(
                 )
             else:
                 text += "SET %s " % compiler.get_identity_options(
-                    sqla_compat.Identity(**{attr: getattr(identity, attr)})
+                    Identity(**{attr: getattr(identity, attr)})
                 )
         return text
 
@@ -846,5 +846,5 @@ def _render_potential_column(
         return render._render_potential_expr(
             value,
             autogen_context,
-            wrap_in_text=isinstance(value, (TextClause, FunctionElement)),
+            wrap_in_element=isinstance(value, (TextClause, FunctionElement)),
         )

alembic/ddl/sqlite.py

@@ -11,6 +11,7 @@ from typing import TYPE_CHECKING
 from typing import Union
 
 from sqlalchemy import cast
+from sqlalchemy import Computed
 from sqlalchemy import JSON
 from sqlalchemy import schema
 from sqlalchemy import sql
@@ -64,7 +65,7 @@ class SQLiteImpl(DefaultImpl):
                 ) and isinstance(col.server_default.arg, sql.ClauseElement):
                     return True
                 elif (
-                    isinstance(col.server_default, util.sqla_compat.Computed)
+                    isinstance(col.server_default, Computed)
                     and col.server_default.persisted
                 ):
                     return True

alembic/op.pyi

@@ -27,7 +27,6 @@ if TYPE_CHECKING:
     from sqlalchemy.sql.elements import conv
     from sqlalchemy.sql.elements import TextClause
     from sqlalchemy.sql.expression import TableClause
-    from sqlalchemy.sql.functions import Function
     from sqlalchemy.sql.schema import Column
     from sqlalchemy.sql.schema import Computed
     from sqlalchemy.sql.schema import Identity
@@ -650,7 +649,7 @@ def create_foreign_key(
 def create_index(
     index_name: Optional[str],
     table_name: str,
-    columns: Sequence[Union[str, TextClause, Function[Any]]],
+    columns: Sequence[Union[str, TextClause, ColumnElement[Any]]],
     *,
     schema: Optional[str] = None,
     unique: bool = False,

alembic/operations/base.py

@@ -43,7 +43,6 @@ if TYPE_CHECKING:
     from sqlalchemy.sql.expression import ColumnElement
     from sqlalchemy.sql.expression import TableClause
     from sqlalchemy.sql.expression import TextClause
-    from sqlalchemy.sql.functions import Function
     from sqlalchemy.sql.schema import Column
     from sqlalchemy.sql.schema import Computed
     from sqlalchemy.sql.schema import Identity
@@ -1074,7 +1073,7 @@ class Operations(AbstractOperations):
             self,
             index_name: Optional[str],
             table_name: str,
-            columns: Sequence[Union[str, TextClause, Function[Any]]],
+            columns: Sequence[Union[str, TextClause, ColumnElement[Any]]],
             *,
             schema: Optional[str] = None,
             unique: bool = False,

alembic/operations/batch.py

@@ -18,6 +18,7 @@ from sqlalchemy import Index
 from sqlalchemy import MetaData
 from sqlalchemy import PrimaryKeyConstraint
 from sqlalchemy import schema as sql_schema
+from sqlalchemy import select
 from sqlalchemy import Table
 from sqlalchemy import types as sqltypes
 from sqlalchemy.sql.schema import SchemaEventTarget
@@ -31,11 +32,9 @@ from ..util.sqla_compat import _copy_expression
 from ..util.sqla_compat import _ensure_scope_for_ddl
 from ..util.sqla_compat import _fk_is_self_referential
 from ..util.sqla_compat import _idx_table_bound_expressions
-from ..util.sqla_compat import _insert_inline
 from ..util.sqla_compat import _is_type_bound
 from ..util.sqla_compat import _remove_column_from_collection
 from ..util.sqla_compat import _resolve_for_variant
-from ..util.sqla_compat import _select
 from ..util.sqla_compat import constraint_name_defined
 from ..util.sqla_compat import constraint_name_string
 
@@ -449,13 +448,15 @@ class ApplyBatchImpl:
 
         try:
             op_impl._exec(
-                _insert_inline(self.new_table).from_select(
+                self.new_table.insert()
+                .inline()
+                .from_select(
                     list(
                         k
                         for k, transfer in self.column_transfers.items()
                         if "expr" in transfer
                     ),
-                    _select(
+                    select(
                         *[
                             transfer["expr"]
                             for transfer in self.column_transfers.values()

alembic/operations/ops.py

@@ -35,7 +35,6 @@ if TYPE_CHECKING:
     from sqlalchemy.sql.elements import conv
     from sqlalchemy.sql.elements import quoted_name
     from sqlalchemy.sql.elements import TextClause
-    from sqlalchemy.sql.functions import Function
     from sqlalchemy.sql.schema import CheckConstraint
     from sqlalchemy.sql.schema import Column
     from sqlalchemy.sql.schema import Computed
@@ -933,7 +932,7 @@ class CreateIndexOp(MigrateOperation):
         operations: Operations,
         index_name: Optional[str],
         table_name: str,
-        columns: Sequence[Union[str, TextClause, Function[Any]]],
+        columns: Sequence[Union[str, TextClause, ColumnElement[Any]]],
         *,
         schema: Optional[str] = None,
         unique: bool = False,

alembic/operations/toimpl.py

@@ -8,7 +8,6 @@ from sqlalchemy import schema as sa_schema
 from . import ops
 from .base import Operations
 from ..util.sqla_compat import _copy
-from ..util.sqla_compat import sqla_14
 
 if TYPE_CHECKING:
     from sqlalchemy.sql.schema import Table
@@ -81,9 +80,6 @@ def alter_column(
 def drop_table(operations: "Operations", operation: "ops.DropTableOp") -> None:
     kw = {}
     if operation.if_exists is not None:
-        if not sqla_14:
-            raise NotImplementedError("SQLAlchemy 1.4+ required")
-
         kw["if_exists"] = operation.if_exists
     operations.impl.drop_table(
         operation.to_table(operations.migration_context), **kw
@@ -107,9 +103,6 @@ def create_index(
     idx = operation.to_index(operations.migration_context)
     kw = {}
     if operation.if_not_exists is not None:
-        if not sqla_14:
-            raise NotImplementedError("SQLAlchemy 1.4+ required")
-
         kw["if_not_exists"] = operation.if_not_exists
     operations.impl.create_index(idx, **kw)
 
@@ -118,9 +111,6 @@ def create_index(
 def drop_index(operations: "Operations", operation: "ops.DropIndexOp") -> None:
     kw = {}
     if operation.if_exists is not None:
-        if not sqla_14:
-            raise NotImplementedError("SQLAlchemy 1.4+ required")
-
         kw["if_exists"] = operation.if_exists
 
     operations.impl.drop_index(
@@ -135,9 +125,6 @@ def create_table(
 ) -> "Table":
     kw = {}
     if operation.if_not_exists is not None:
-        if not sqla_14:
-            raise NotImplementedError("SQLAlchemy 1.4+ required")
-
         kw["if_not_exists"] = operation.if_not_exists
     table = operation.to_table(operations.migration_context)
     operations.impl.create_table(table, **kw)

alembic/runtime/environment.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from typing import Any
 from typing import Callable
 from typing import Collection
-from typing import ContextManager
 from typing import Dict
 from typing import List
 from typing import Mapping
@@ -18,6 +17,7 @@ from typing import Union
 
 from sqlalchemy.sql.schema import Column
 from sqlalchemy.sql.schema import FetchedValue
+from typing_extensions import ContextManager
 from typing_extensions import Literal
 
 from .migration import _ProxyTransaction
@@ -976,7 +976,7 @@ class EnvironmentContext(util.ModuleClsProxy):
 
     def begin_transaction(
         self,
-    ) -> Union[_ProxyTransaction, ContextManager[None]]:
+    ) -> Union[_ProxyTransaction, ContextManager[None, Optional[bool]]]:
         """Return a context manager that will
         enclose an operation within a "transaction",
         as defined by the environment's offline

alembic/runtime/migration.py

@@ -11,7 +11,6 @@ from typing import Any
 from typing import Callable
 from typing import cast
 from typing import Collection
-from typing import ContextManager
 from typing import Dict
 from typing import Iterable
 from typing import Iterator
@@ -24,15 +23,16 @@ from typing import Union
 
 from sqlalchemy import Column
 from sqlalchemy import literal_column
+from sqlalchemy import select
 from sqlalchemy.engine import Engine
 from sqlalchemy.engine import url as sqla_url
 from sqlalchemy.engine.strategies import MockEngineStrategy
+from typing_extensions import ContextManager
 
 from .. import ddl
 from .. import util
 from ..util import sqla_compat
 from ..util.compat import EncodedIO
-from ..util.sqla_compat import _select
 
 if TYPE_CHECKING:
     from sqlalchemy.engine import Dialect
@@ -368,7 +368,7 @@ class MigrationContext:
 
     def begin_transaction(
         self, _per_migration: bool = False
-    ) -> Union[_ProxyTransaction, ContextManager[None]]:
+    ) -> Union[_ProxyTransaction, ContextManager[None, Optional[bool]]]:
         """Begin a logical transaction for migration operations.
 
         This method is used within an ``env.py`` script to demarcate where
@@ -534,7 +534,7 @@ class MigrationContext:
         return tuple(
             row[0]
             for row in self.connection.execute(
-                _select(self._version.c.version_num)
+                select(self._version.c.version_num)
             )
         )
 

alembic/testing/assertions.py

@@ -8,6 +8,7 @@ from typing import Dict
 
 from sqlalchemy import exc as sa_exc
 from sqlalchemy.engine import default
+from sqlalchemy.engine import URL
 from sqlalchemy.testing.assertions import _expect_warnings
 from sqlalchemy.testing.assertions import eq_  # noqa
 from sqlalchemy.testing.assertions import is_  # noqa
@@ -17,8 +18,6 @@ from sqlalchemy.testing.assertions import is_true  # noqa
 from sqlalchemy.testing.assertions import ne_  # noqa
 from sqlalchemy.util import decorator
 
-from ..util import sqla_compat
-
 
 def _assert_proper_exception_context(exception):
     """assert that any exception we're catching does not have a __context__
@@ -127,7 +126,7 @@ def _get_dialect(name):
     if name is None or name == "default":
         return default.DefaultDialect()
     else:
-        d = sqla_compat._create_url(name).get_dialect()()
+        d = URL.create(name).get_dialect()()
 
         if name == "postgresql":
             d.implicit_returning = True