alembic 1.13.0__py3-none-any.whl → 1.13.1__py3-none-any.whl

alembic/ddl/postgresql.py

@@ -1,3 +1,6 @@
+# mypy: allow-untyped-defs, allow-incomplete-defs, allow-untyped-calls
+# mypy: no-warn-return-any, allow-any-generics
+
 from __future__ import annotations
 
 import logging
@@ -30,7 +33,6 @@ from .base import alter_column
 from .base import alter_table
 from .base import AlterColumn
 from .base import ColumnComment
-from .base import compiles
 from .base import format_column_name
 from .base import format_table_name
 from .base import format_type
@@ -45,6 +47,7 @@ from ..operations import schemaobj
 from ..operations.base import BatchOperations
 from ..operations.base import Operations
 from ..util import sqla_compat
+from ..util.sqla_compat import compiles
 
 if TYPE_CHECKING:
     from typing import Literal
@@ -136,7 +139,9 @@ class PostgresqlImpl(DefaultImpl):
             metadata_default = literal_column(metadata_default)
 
         # run a real compare against the server
-        return not self.connection.scalar(
+        conn = self.connection
+        assert conn is not None
+        return not conn.scalar(
             sqla_compat._select(
                 literal_column(conn_col_default) == metadata_default
             )
@@ -623,9 +628,8 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
         return cls(
             constraint.name,
             constraint_table.name,
-            [
-                (expr, op)
-                for expr, name, op in constraint._render_exprs  # type:ignore[attr-defined] # noqa
+            [  # type: ignore
+                (expr, op) for expr, name, op in constraint._render_exprs
             ],
             where=cast("ColumnElement[bool] | None", constraint.where),
             schema=constraint_table.schema,
@@ -652,7 +656,7 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
             expr,
             name,
             oper,
-        ) in excl._render_exprs:  # type:ignore[attr-defined]
+        ) in excl._render_exprs:
             t.append_column(Column(name, NULLTYPE))
         t.append_constraint(excl)
         return excl
@@ -710,7 +714,7 @@ class CreateExcludeConstraintOp(ops.AddConstraintOp):
         constraint_name: str,
         *elements: Any,
         **kw: Any,
-    ):
+    ) -> Optional[Table]:
         """Issue a "create exclude constraint" instruction using the
         current batch migration context.
 
@@ -782,10 +786,13 @@ def _exclude_constraint(
         args = [
             "(%s, %r)"
             % (
-                _render_potential_column(sqltext, autogen_context),
+                _render_potential_column(
+                    sqltext,  # type:ignore[arg-type]
+                    autogen_context,
+                ),
                 opstring,
             )
-            for sqltext, name, opstring in constraint._render_exprs  # type:ignore[attr-defined] # noqa
+            for sqltext, name, opstring in constraint._render_exprs
         ]
         if constraint.where is not None:
             args.append(

alembic/ddl/sqlite.py

@@ -1,3 +1,6 @@
+# mypy: allow-untyped-defs, allow-incomplete-defs, allow-untyped-calls
+# mypy: no-warn-return-any, allow-any-generics
+
 from __future__ import annotations
 
 import re
@@ -11,13 +14,13 @@ from sqlalchemy import cast
 from sqlalchemy import JSON
 from sqlalchemy import schema
 from sqlalchemy import sql
-from sqlalchemy.ext.compiler import compiles
 
 from .base import alter_table
 from .base import format_table_name
 from .base import RenameTable
 from .impl import DefaultImpl
 from .. import util
+from ..util.sqla_compat import compiles
 
 if TYPE_CHECKING:
     from sqlalchemy.engine.reflection import Inspector
@@ -71,13 +74,13 @@ class SQLiteImpl(DefaultImpl):
     def add_constraint(self, const: Constraint):
         # attempt to distinguish between an
         # auto-gen constraint and an explicit one
-        if const._create_rule is None:  # type:ignore[attr-defined]
+        if const._create_rule is None:
             raise NotImplementedError(
                 "No support for ALTER of constraints in SQLite dialect. "
                 "Please refer to the batch mode feature which allows for "
                 "SQLite migrations using a copy-and-move strategy."
             )
-        elif const._create_rule(self):  # type:ignore[attr-defined]
+        elif const._create_rule(self):
             util.warn(
                 "Skipping unsupported ALTER for "
                 "creation of implicit constraint. "
@@ -86,7 +89,7 @@ class SQLiteImpl(DefaultImpl):
             )
 
     def drop_constraint(self, const: Constraint):
-        if const._create_rule is None:  # type:ignore[attr-defined]
+        if const._create_rule is None:
             raise NotImplementedError(
                 "No support for ALTER of constraints in SQLite dialect. "
                 "Please refer to the batch mode feature which allows for "
@@ -177,8 +180,7 @@ class SQLiteImpl(DefaultImpl):
         new_type: TypeEngine,
     ) -> None:
         if (
-            existing.type._type_affinity  # type:ignore[attr-defined]
-            is not new_type._type_affinity  # type:ignore[attr-defined]
+            existing.type._type_affinity is not new_type._type_affinity
             and not isinstance(new_type, JSON)
         ):
             existing_transfer["expr"] = cast(

alembic/op.pyi

@@ -12,6 +12,7 @@ from typing import List
 from typing import Literal
 from typing import Mapping
 from typing import Optional
+from typing import overload
 from typing import Sequence
 from typing import Tuple
 from typing import Type
@@ -35,12 +36,28 @@ if TYPE_CHECKING:
     from sqlalchemy.sql.type_api import TypeEngine
     from sqlalchemy.util import immutabledict
 
-    from .operations.ops import BatchOperations
+    from .operations.base import BatchOperations
+    from .operations.ops import AddColumnOp
+    from .operations.ops import AddConstraintOp
+    from .operations.ops import AlterColumnOp
+    from .operations.ops import AlterTableOp
+    from .operations.ops import BulkInsertOp
+    from .operations.ops import CreateIndexOp
+    from .operations.ops import CreateTableCommentOp
+    from .operations.ops import CreateTableOp
+    from .operations.ops import DropColumnOp
+    from .operations.ops import DropConstraintOp
+    from .operations.ops import DropIndexOp
+    from .operations.ops import DropTableCommentOp
+    from .operations.ops import DropTableOp
+    from .operations.ops import ExecuteSQLOp
     from .operations.ops import MigrateOperation
     from .runtime.migration import MigrationContext
     from .util.sqla_compat import _literal_bindparam
 
 _T = TypeVar("_T")
+_C = TypeVar("_C", bound=Callable[..., Any])
+
 ### end imports ###
 
 def add_column(
@@ -132,8 +149,8 @@ def alter_column(
     comment: Union[str, Literal[False], None] = False,
     server_default: Any = False,
     new_column_name: Optional[str] = None,
-    type_: Union[TypeEngine, Type[TypeEngine], None] = None,
-    existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
+    type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
+    existing_type: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
     existing_server_default: Union[
         str, bool, Identity, Computed, None
     ] = False,
@@ -230,7 +247,7 @@ def batch_alter_table(
     table_name: str,
     schema: Optional[str] = None,
     recreate: Literal["auto", "always", "never"] = "auto",
-    partial_reordering: Optional[tuple] = None,
+    partial_reordering: Optional[Tuple[Any, ...]] = None,
     copy_from: Optional[Table] = None,
     table_args: Tuple[Any, ...] = (),
     table_kwargs: Mapping[str, Any] = immutabledict({}),
@@ -377,7 +394,7 @@ def batch_alter_table(
 
 def bulk_insert(
     table: Union[Table, TableClause],
-    rows: List[dict],
+    rows: List[Dict[str, Any]],
     *,
     multiinsert: bool = True,
 ) -> None:
@@ -1162,7 +1179,7 @@ def get_context() -> MigrationContext:
 
     """
 
-def implementation_for(op_cls: Any) -> Callable[..., Any]:
+def implementation_for(op_cls: Any) -> Callable[[_C], _C]:
     """Register an implementation for a given :class:`.MigrateOperation`.
 
     This is part of the operation extensibility API.
@@ -1174,7 +1191,7 @@ def implementation_for(op_cls: Any) -> Callable[..., Any]:
     """
 
 def inline_literal(
-    value: Union[str, int], type_: Optional[TypeEngine] = None
+    value: Union[str, int], type_: Optional[TypeEngine[Any]] = None
 ) -> _literal_bindparam:
     r"""Produce an 'inline literal' expression, suitable for
     using in an INSERT, UPDATE, or DELETE statement.
@@ -1218,6 +1235,27 @@ def inline_literal(
 
     """
 
+@overload
+def invoke(operation: CreateTableOp) -> Table: ...
+@overload
+def invoke(
+    operation: Union[
+        AddConstraintOp,
+        DropConstraintOp,
+        CreateIndexOp,
+        DropIndexOp,
+        AddColumnOp,
+        AlterColumnOp,
+        AlterTableOp,
+        CreateTableCommentOp,
+        DropTableCommentOp,
+        DropColumnOp,
+        BulkInsertOp,
+        DropTableOp,
+        ExecuteSQLOp,
+    ]
+) -> None: ...
+@overload
 def invoke(operation: MigrateOperation) -> Any:
     """Given a :class:`.MigrateOperation`, invoke it in terms of
     this :class:`.Operations` instance.
@@ -1226,7 +1264,7 @@ def invoke(operation: MigrateOperation) -> Any:
 
 def register_operation(
     name: str, sourcename: Optional[str] = None
-) -> Callable[[_T], _T]:
+) -> Callable[[Type[_T]], Type[_T]]:
     """Register a new operation for this class.
 
     This method is normally used to add new operations

alembic/operations/base.py

@@ -1,3 +1,5 @@
+# mypy: allow-untyped-calls
+
 from __future__ import annotations
 
 from contextlib import contextmanager
@@ -10,7 +12,9 @@ from typing import Dict
 from typing import Iterator
 from typing import List  # noqa
 from typing import Mapping
+from typing import NoReturn
 from typing import Optional
+from typing import overload
 from typing import Sequence  # noqa
 from typing import Tuple
 from typing import Type  # noqa
@@ -47,12 +51,28 @@ if TYPE_CHECKING:
     from sqlalchemy.types import TypeEngine
 
     from .batch import BatchOperationsImpl
+    from .ops import AddColumnOp
+    from .ops import AddConstraintOp
+    from .ops import AlterColumnOp
+    from .ops import AlterTableOp
+    from .ops import BulkInsertOp
+    from .ops import CreateIndexOp
+    from .ops import CreateTableCommentOp
+    from .ops import CreateTableOp
+    from .ops import DropColumnOp
+    from .ops import DropConstraintOp
+    from .ops import DropIndexOp
+    from .ops import DropTableCommentOp
+    from .ops import DropTableOp
+    from .ops import ExecuteSQLOp
     from .ops import MigrateOperation
     from ..ddl import DefaultImpl
     from ..runtime.migration import MigrationContext
 __all__ = ("Operations", "BatchOperations")
 _T = TypeVar("_T")
 
+_C = TypeVar("_C", bound=Callable[..., Any])
+
 
 class AbstractOperations(util.ModuleClsProxy):
     """Base class for Operations and BatchOperations.
@@ -86,7 +106,7 @@ class AbstractOperations(util.ModuleClsProxy):
     @classmethod
     def register_operation(
         cls, name: str, sourcename: Optional[str] = None
-    ) -> Callable[[_T], _T]:
+    ) -> Callable[[Type[_T]], Type[_T]]:
         """Register a new operation for this class.
 
         This method is normally used to add new operations
@@ -103,7 +123,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
         """
 
-        def register(op_cls):
+        def register(op_cls: Type[_T]) -> Type[_T]:
             if sourcename is None:
                 fn = getattr(op_cls, name)
                 source_name = fn.__name__
@@ -122,8 +142,11 @@ class AbstractOperations(util.ModuleClsProxy):
                 *spec, formatannotation=formatannotation_fwdref
             )
             num_defaults = len(spec[3]) if spec[3] else 0
+
+            defaulted_vals: Tuple[Any, ...]
+
             if num_defaults:
-                defaulted_vals = name_args[0 - num_defaults :]
+                defaulted_vals = tuple(name_args[0 - num_defaults :])
             else:
                 defaulted_vals = ()
 
@@ -164,7 +187,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
             globals_ = dict(globals())
             globals_.update({"op_cls": op_cls})
-            lcl = {}
+            lcl: Dict[str, Any] = {}
 
             exec(func_text, globals_, lcl)
             setattr(cls, name, lcl[name])
@@ -180,7 +203,7 @@ class AbstractOperations(util.ModuleClsProxy):
         return register
 
     @classmethod
-    def implementation_for(cls, op_cls: Any) -> Callable[..., Any]:
+    def implementation_for(cls, op_cls: Any) -> Callable[[_C], _C]:
         """Register an implementation for a given :class:`.MigrateOperation`.
 
         This is part of the operation extensibility API.
@@ -191,7 +214,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
         """
 
-        def decorate(fn):
+        def decorate(fn: _C) -> _C:
             cls._to_impl.dispatch_for(op_cls)(fn)
             return fn
 
@@ -213,7 +236,7 @@ class AbstractOperations(util.ModuleClsProxy):
         table_name: str,
         schema: Optional[str] = None,
         recreate: Literal["auto", "always", "never"] = "auto",
-        partial_reordering: Optional[tuple] = None,
+        partial_reordering: Optional[Tuple[Any, ...]] = None,
         copy_from: Optional[Table] = None,
         table_args: Tuple[Any, ...] = (),
         table_kwargs: Mapping[str, Any] = util.immutabledict(),
@@ -382,6 +405,35 @@ class AbstractOperations(util.ModuleClsProxy):
 
         return self.migration_context
 
+    @overload
+    def invoke(self, operation: CreateTableOp) -> Table:
+        ...
+
+    @overload
+    def invoke(
+        self,
+        operation: Union[
+            AddConstraintOp,
+            DropConstraintOp,
+            CreateIndexOp,
+            DropIndexOp,
+            AddColumnOp,
+            AlterColumnOp,
+            AlterTableOp,
+            CreateTableCommentOp,
+            DropTableCommentOp,
+            DropColumnOp,
+            BulkInsertOp,
+            DropTableOp,
+            ExecuteSQLOp,
+        ],
+    ) -> None:
+        ...
+
+    @overload
+    def invoke(self, operation: MigrateOperation) -> Any:
+        ...
+
     def invoke(self, operation: MigrateOperation) -> Any:
         """Given a :class:`.MigrateOperation`, invoke it in terms of
         this :class:`.Operations` instance.
@@ -659,8 +711,10 @@ class Operations(AbstractOperations):
             comment: Union[str, Literal[False], None] = False,
             server_default: Any = False,
             new_column_name: Optional[str] = None,
-            type_: Union[TypeEngine, Type[TypeEngine], None] = None,
-            existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
+            type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
+            existing_type: Union[
+                TypeEngine[Any], Type[TypeEngine[Any]], None
+            ] = None,
             existing_server_default: Union[
                 str, bool, Identity, Computed, None
             ] = False,
@@ -756,7 +810,7 @@ class Operations(AbstractOperations):
         def bulk_insert(
             self,
             table: Union[Table, TableClause],
-            rows: List[dict],
+            rows: List[Dict[str, Any]],
             *,
             multiinsert: bool = True,
         ) -> None:
@@ -1560,7 +1614,7 @@ class BatchOperations(AbstractOperations):
 
     impl: BatchOperationsImpl
 
-    def _noop(self, operation):
+    def _noop(self, operation: Any) -> NoReturn:
         raise NotImplementedError(
             "The %s method does not apply to a batch table alter operation."
             % operation
@@ -1596,8 +1650,10 @@ class BatchOperations(AbstractOperations):
             comment: Union[str, Literal[False], None] = False,
             server_default: Any = False,
             new_column_name: Optional[str] = None,
-            type_: Union[TypeEngine, Type[TypeEngine], None] = None,
-            existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
+            type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
+            existing_type: Union[
+                TypeEngine[Any], Type[TypeEngine[Any]], None
+            ] = None,
             existing_server_default: Union[
                 str, bool, Identity, Computed, None
             ] = False,
@@ -1652,7 +1708,7 @@ class BatchOperations(AbstractOperations):
 
         def create_exclude_constraint(
             self, constraint_name: str, *elements: Any, **kw: Any
-        ):
+        ) -> Optional[Table]:
             """Issue a "create exclude constraint" instruction using the
             current batch migration context.
 

alembic/operations/batch.py

@@ -1,3 +1,6 @@
+# mypy: allow-untyped-defs, allow-incomplete-defs, allow-untyped-calls
+# mypy: no-warn-return-any, allow-any-generics
+
 from __future__ import annotations
 
 from typing import Any
@@ -17,7 +20,7 @@ from sqlalchemy import PrimaryKeyConstraint
 from sqlalchemy import schema as sql_schema
 from sqlalchemy import Table
 from sqlalchemy import types as sqltypes
-from sqlalchemy.events import SchemaEventTarget
+from sqlalchemy.sql.schema import SchemaEventTarget
 from sqlalchemy.util import OrderedDict
 from sqlalchemy.util import topological
 
@@ -374,7 +377,7 @@ class ApplyBatchImpl:
         for idx_existing in self.indexes.values():
             # this is a lift-and-move from Table.to_metadata
 
-            if idx_existing._column_flag:  # type: ignore
+            if idx_existing._column_flag:
                 continue
 
             idx_copy = Index(
@@ -403,9 +406,7 @@ class ApplyBatchImpl:
     def _setup_referent(
         self, metadata: MetaData, constraint: ForeignKeyConstraint
     ) -> None:
-        spec = constraint.elements[
-            0
-        ]._get_colspec()  # type:ignore[attr-defined]
+        spec = constraint.elements[0]._get_colspec()
         parts = spec.split(".")
         tname = parts[-2]
         if len(parts) == 3:
@@ -546,9 +547,7 @@ class ApplyBatchImpl:
             else:
                 sql_schema.DefaultClause(
                     server_default  # type: ignore[arg-type]
-                )._set_parent(  # type:ignore[attr-defined]
-                    existing
-                )
+                )._set_parent(existing)
         if autoincrement is not None:
             existing.autoincrement = bool(autoincrement)