main commit

venv/lib/python3.12/site-packages/alembic/operations/base.py

@@ -1,5 +1,3 @@
-# mypy: allow-untyped-calls
-
 from __future__ import annotations
 
 from contextlib import contextmanager
@@ -12,9 +10,7 @@ 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
@@ -43,6 +39,7 @@ 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
@@ -50,28 +47,12 @@ 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.
@@ -105,7 +86,7 @@ class AbstractOperations(util.ModuleClsProxy):
     @classmethod
     def register_operation(
         cls, name: str, sourcename: Optional[str] = None
-    ) -> Callable[[Type[_T]], Type[_T]]:
+    ) -> Callable[[_T], _T]:
         """Register a new operation for this class.
 
         This method is normally used to add new operations
@@ -122,7 +103,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
         """
 
-        def register(op_cls: Type[_T]) -> Type[_T]:
+        def register(op_cls):
             if sourcename is None:
                 fn = getattr(op_cls, name)
                 source_name = fn.__name__
@@ -141,11 +122,8 @@ 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 = tuple(name_args[0 - num_defaults :])
+                defaulted_vals = name_args[0 - num_defaults :]
             else:
                 defaulted_vals = ()
 
@@ -186,7 +164,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
             globals_ = dict(globals())
             globals_.update({"op_cls": op_cls})
-            lcl: Dict[str, Any] = {}
+            lcl = {}
 
             exec(func_text, globals_, lcl)
             setattr(cls, name, lcl[name])
@@ -202,7 +180,7 @@ class AbstractOperations(util.ModuleClsProxy):
         return register
 
     @classmethod
-    def implementation_for(cls, op_cls: Any) -> Callable[[_C], _C]:
+    def implementation_for(cls, op_cls: Any) -> Callable[..., Any]:
         """Register an implementation for a given :class:`.MigrateOperation`.
 
         This is part of the operation extensibility API.
@@ -213,7 +191,7 @@ class AbstractOperations(util.ModuleClsProxy):
 
         """
 
-        def decorate(fn: _C) -> _C:
+        def decorate(fn):
             cls._to_impl.dispatch_for(op_cls)(fn)
             return fn
 
@@ -235,7 +213,7 @@ class AbstractOperations(util.ModuleClsProxy):
         table_name: str,
         schema: Optional[str] = None,
         recreate: Literal["auto", "always", "never"] = "auto",
-        partial_reordering: Optional[Tuple[Any, ...]] = None,
+        partial_reordering: Optional[tuple] = None,
         copy_from: Optional[Table] = None,
         table_args: Tuple[Any, ...] = (),
         table_kwargs: Mapping[str, Any] = util.immutabledict(),
@@ -404,32 +382,6 @@ 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.
@@ -464,7 +416,7 @@ class AbstractOperations(util.ModuleClsProxy):
         names will be converted along conventions.  If the ``target_metadata``
         contains the naming convention
         ``{"ck": "ck_bool_%(table_name)s_%(constraint_name)s"}``, then the
-        output of the following::
+        output of the following:
 
             op.add_column("t", "x", Boolean(name="x"))
 
@@ -618,7 +570,6 @@ class Operations(AbstractOperations):
             column: Column[Any],
             *,
             schema: Optional[str] = None,
-            if_not_exists: Optional[bool] = None,
         ) -> None:
             """Issue an "add column" instruction using the current
             migration context.
@@ -695,10 +646,6 @@ class Operations(AbstractOperations):
              quoting of the schema outside of the default behavior, use
              the SQLAlchemy construct
              :class:`~sqlalchemy.sql.elements.quoted_name`.
-            :param if_not_exists: If True, adds IF NOT EXISTS operator
-             when creating the new column for compatible dialects
-
-             .. versionadded:: 1.16.0
 
             """  # noqa: E501
             ...
@@ -710,16 +657,12 @@ class Operations(AbstractOperations):
             *,
             nullable: Optional[bool] = None,
             comment: Union[str, Literal[False], None] = False,
-            server_default: Union[
-                str, bool, Identity, Computed, TextClause, None
-            ] = False,
+            server_default: Any = False,
             new_column_name: Optional[str] = None,
-            type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
-            existing_type: Union[
-                TypeEngine[Any], Type[TypeEngine[Any]], None
-            ] = None,
+            type_: Union[TypeEngine, Type[TypeEngine], None] = None,
+            existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
             existing_server_default: Union[
-                str, bool, Identity, Computed, TextClause, None
+                str, bool, Identity, Computed, None
             ] = False,
             existing_nullable: Optional[bool] = None,
             existing_comment: Optional[str] = None,
@@ -813,7 +756,7 @@ class Operations(AbstractOperations):
         def bulk_insert(
             self,
             table: Union[Table, TableClause],
-            rows: List[Dict[str, Any]],
+            rows: List[dict],
             *,
             multiinsert: bool = True,
         ) -> None:
@@ -1080,7 +1023,7 @@ class Operations(AbstractOperations):
             self,
             index_name: Optional[str],
             table_name: str,
-            columns: Sequence[Union[str, TextClause, ColumnElement[Any]]],
+            columns: Sequence[Union[str, TextClause, Function[Any]]],
             *,
             schema: Optional[str] = None,
             unique: bool = False,
@@ -1181,11 +1124,7 @@ class Operations(AbstractOperations):
             ...
 
         def create_table(
-            self,
-            table_name: str,
-            *columns: SchemaItem,
-            if_not_exists: Optional[bool] = None,
-            **kw: Any,
+            self, table_name: str, *columns: SchemaItem, **kw: Any
         ) -> Table:
             r"""Issue a "create table" instruction using the current migration
             context.
@@ -1257,10 +1196,6 @@ class Operations(AbstractOperations):
              quoting of the schema outside of the default behavior, use
              the SQLAlchemy construct
              :class:`~sqlalchemy.sql.elements.quoted_name`.
-            :param if_not_exists: If True, adds IF NOT EXISTS operator when
-             creating the new table.
-
-             .. versionadded:: 1.13.3
             :param \**kw: Other keyword arguments are passed to the underlying
              :class:`sqlalchemy.schema.Table` object created for the command.
 
@@ -1366,11 +1301,6 @@ class Operations(AbstractOperations):
              quoting of the schema outside of the default behavior, use
              the SQLAlchemy construct
              :class:`~sqlalchemy.sql.elements.quoted_name`.
-            :param if_exists: If True, adds IF EXISTS operator when
-             dropping the new column for compatible dialects
-
-             .. versionadded:: 1.16.0
-
             :param mssql_drop_check: Optional boolean.  When ``True``, on
              Microsoft SQL Server only, first
              drop the CHECK constraint on the column using a
@@ -1392,6 +1322,7 @@ class Operations(AbstractOperations):
              then exec's a separate DROP CONSTRAINT for that default.  Only
              works if the column has exactly one FK constraint which refers to
              it, at the moment.
+
             """  # noqa: E501
             ...
 
@@ -1402,7 +1333,6 @@ class Operations(AbstractOperations):
             type_: Optional[str] = None,
             *,
             schema: Optional[str] = None,
-            if_exists: Optional[bool] = None,
         ) -> None:
             r"""Drop a constraint of the given name, typically via DROP CONSTRAINT.
 
@@ -1414,10 +1344,6 @@ class Operations(AbstractOperations):
              quoting of the schema outside of the default behavior, use
              the SQLAlchemy construct
              :class:`~sqlalchemy.sql.elements.quoted_name`.
-            :param if_exists: If True, adds IF EXISTS operator when
-             dropping the constraint
-
-             .. versionadded:: 1.16.0
 
             """  # noqa: E501
             ...
@@ -1461,12 +1387,7 @@ class Operations(AbstractOperations):
             ...
 
         def drop_table(
-            self,
-            table_name: str,
-            *,
-            schema: Optional[str] = None,
-            if_exists: Optional[bool] = None,
-            **kw: Any,
+            self, table_name: str, *, schema: Optional[str] = None, **kw: Any
         ) -> None:
             r"""Issue a "drop table" instruction using the current
             migration context.
@@ -1481,10 +1402,6 @@ class Operations(AbstractOperations):
              quoting of the schema outside of the default behavior, use
              the SQLAlchemy construct
              :class:`~sqlalchemy.sql.elements.quoted_name`.
-            :param if_exists: If True, adds IF EXISTS operator when
-             dropping the table.
-
-             .. versionadded:: 1.13.3
             :param \**kw: Other keyword arguments are passed to the underlying
              :class:`sqlalchemy.schema.Table` object created for the command.
 
@@ -1643,7 +1560,7 @@ class BatchOperations(AbstractOperations):
 
     impl: BatchOperationsImpl
 
-    def _noop(self, operation: Any) -> NoReturn:
+    def _noop(self, operation):
         raise NotImplementedError(
             "The %s method does not apply to a batch table alter operation."
             % operation
@@ -1660,7 +1577,6 @@ class BatchOperations(AbstractOperations):
             *,
             insert_before: Optional[str] = None,
             insert_after: Optional[str] = None,
-            if_not_exists: Optional[bool] = None,
         ) -> None:
             """Issue an "add column" instruction using the current
             batch migration context.
@@ -1680,10 +1596,8 @@ class BatchOperations(AbstractOperations):
             comment: Union[str, Literal[False], None] = False,
             server_default: Any = False,
             new_column_name: Optional[str] = None,
-            type_: Union[TypeEngine[Any], Type[TypeEngine[Any]], None] = None,
-            existing_type: Union[
-                TypeEngine[Any], Type[TypeEngine[Any]], None
-            ] = None,
+            type_: Union[TypeEngine, Type[TypeEngine], None] = None,
+            existing_type: Union[TypeEngine, Type[TypeEngine], None] = None,
             existing_server_default: Union[
                 str, bool, Identity, Computed, None
             ] = False,
@@ -1738,7 +1652,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.
 
@@ -1754,7 +1668,7 @@ class BatchOperations(AbstractOperations):
 
         def create_foreign_key(
             self,
-            constraint_name: Optional[str],
+            constraint_name: str,
             referent_table: str,
             local_cols: List[str],
             remote_cols: List[str],
@@ -1804,7 +1718,7 @@ class BatchOperations(AbstractOperations):
             ...
 
         def create_primary_key(
-            self, constraint_name: Optional[str], columns: List[str]
+            self, constraint_name: str, columns: List[str]
         ) -> None:
             """Issue a "create primary key" instruction using the
             current batch migration context.

venv/lib/python3.12/site-packages/alembic/operations/batch.py

@@ -1,6 +1,3 @@
-# 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
@@ -18,10 +15,9 @@ 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
+from sqlalchemy.events import SchemaEventTarget
 from sqlalchemy.util import OrderedDict
 from sqlalchemy.util import topological
 
@@ -32,9 +28,11 @@ 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
 
@@ -376,7 +374,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:
+            if idx_existing._column_flag:  # type: ignore
                 continue
 
             idx_copy = Index(
@@ -405,7 +403,9 @@ class ApplyBatchImpl:
     def _setup_referent(
         self, metadata: MetaData, constraint: ForeignKeyConstraint
     ) -> None:
-        spec = constraint.elements[0]._get_colspec()
+        spec = constraint.elements[
+            0
+        ]._get_colspec()  # type:ignore[attr-defined]
         parts = spec.split(".")
         tname = parts[-2]
         if len(parts) == 3:
@@ -448,15 +448,13 @@ class ApplyBatchImpl:
 
         try:
             op_impl._exec(
-                self.new_table.insert()
-                .inline()
-                .from_select(
+                _insert_inline(self.new_table).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()
@@ -548,7 +546,9 @@ class ApplyBatchImpl:
             else:
                 sql_schema.DefaultClause(
                     server_default  # type: ignore[arg-type]
-                )._set_parent(existing)
+                )._set_parent(  # type:ignore[attr-defined]
+                    existing
+                )
         if autoincrement is not None:
             existing.autoincrement = bool(autoincrement)
 

venv/lib/python3.12/site-packages/alembic/operations/ops.py

@@ -1,13 +1,10 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-import os
-import pathlib
 import re
 from typing import Any
 from typing import Callable
 from typing import cast
-from typing import Dict
 from typing import FrozenSet
 from typing import Iterator
 from typing import List
@@ -18,7 +15,6 @@ from typing import Set
 from typing import Tuple
 from typing import Type
 from typing import TYPE_CHECKING
-from typing import TypeVar
 from typing import Union
 
 from sqlalchemy.types import NULLTYPE
@@ -37,6 +33,7 @@ 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
@@ -56,9 +53,6 @@ if TYPE_CHECKING:
     from ..runtime.migration import MigrationContext
     from ..script.revision import _RevIdType
 
-_T = TypeVar("_T", bound=Any)
-_AC = TypeVar("_AC", bound="AddConstraintOp")
-
 
 class MigrateOperation:
     """base class for migration command and organization objects.
@@ -76,7 +70,7 @@ class MigrateOperation:
     """
 
     @util.memoized_property
-    def info(self) -> Dict[Any, Any]:
+    def info(self):
         """A dictionary that may be used to store arbitrary information
         along with this :class:`.MigrateOperation` object.
 
@@ -98,14 +92,12 @@ class AddConstraintOp(MigrateOperation):
     add_constraint_ops = util.Dispatcher()
 
     @property
-    def constraint_type(self) -> str:
+    def constraint_type(self):
         raise NotImplementedError()
 
     @classmethod
-    def register_add_constraint(
-        cls, type_: str
-    ) -> Callable[[Type[_AC]], Type[_AC]]:
-        def go(klass: Type[_AC]) -> Type[_AC]:
+    def register_add_constraint(cls, type_: str) -> Callable:
+        def go(klass):
             cls.add_constraint_ops.dispatch_for(type_)(klass.from_constraint)
             return klass
 
@@ -113,7 +105,7 @@ class AddConstraintOp(MigrateOperation):
 
     @classmethod
     def from_constraint(cls, constraint: Constraint) -> AddConstraintOp:
-        return cls.add_constraint_ops.dispatch(constraint.__visit_name__)(  # type: ignore[no-any-return]  # noqa: E501
+        return cls.add_constraint_ops.dispatch(constraint.__visit_name__)(
             constraint
         )
 
@@ -142,14 +134,12 @@ class DropConstraintOp(MigrateOperation):
         type_: Optional[str] = None,
         *,
         schema: Optional[str] = None,
-        if_exists: Optional[bool] = None,
         _reverse: Optional[AddConstraintOp] = None,
     ) -> None:
         self.constraint_name = constraint_name
         self.table_name = table_name
         self.constraint_type = type_
         self.schema = schema
-        self.if_exists = if_exists
         self._reverse = _reverse
 
     def reverse(self) -> AddConstraintOp:
@@ -207,7 +197,6 @@ class DropConstraintOp(MigrateOperation):
         type_: Optional[str] = None,
         *,
         schema: Optional[str] = None,
-        if_exists: Optional[bool] = None,
     ) -> None:
         r"""Drop a constraint of the given name, typically via DROP CONSTRAINT.
 
@@ -219,20 +208,10 @@ class DropConstraintOp(MigrateOperation):
          quoting of the schema outside of the default behavior, use
          the SQLAlchemy construct
          :class:`~sqlalchemy.sql.elements.quoted_name`.
-        :param if_exists: If True, adds IF EXISTS operator when
-         dropping the constraint
-
-         .. versionadded:: 1.16.0
 
         """
 
-        op = cls(
-            constraint_name,
-            table_name,
-            type_=type_,
-            schema=schema,
-            if_exists=if_exists,
-        )
+        op = cls(constraint_name, table_name, type_=type_, schema=schema)
         return operations.invoke(op)
 
     @classmethod
@@ -363,7 +342,7 @@ class CreatePrimaryKeyOp(AddConstraintOp):
     def batch_create_primary_key(
         cls,
         operations: BatchOperations,
-        constraint_name: Optional[str],
+        constraint_name: str,
         columns: List[str],
     ) -> None:
         """Issue a "create primary key" instruction using the
@@ -419,7 +398,7 @@ class CreateUniqueConstraintOp(AddConstraintOp):
 
         uq_constraint = cast("UniqueConstraint", constraint)
 
-        kw: Dict[str, Any] = {}
+        kw: dict = {}
         if uq_constraint.deferrable:
             kw["deferrable"] = uq_constraint.deferrable
         if uq_constraint.initially:
@@ -553,7 +532,7 @@ class CreateForeignKeyOp(AddConstraintOp):
     @classmethod
     def from_constraint(cls, constraint: Constraint) -> CreateForeignKeyOp:
         fk_constraint = cast("ForeignKeyConstraint", constraint)
-        kw: Dict[str, Any] = {}
+        kw: dict = {}
         if fk_constraint.onupdate:
             kw["onupdate"] = fk_constraint.onupdate
         if fk_constraint.ondelete:
@@ -695,7 +674,7 @@ class CreateForeignKeyOp(AddConstraintOp):
     def batch_create_foreign_key(
         cls,
         operations: BatchOperations,
-        constraint_name: Optional[str],
+        constraint_name: str,
         referent_table: str,
         local_cols: List[str],
         remote_cols: List[str],
@@ -918,9 +897,9 @@ class CreateIndexOp(MigrateOperation):
     def from_index(cls, index: Index) -> CreateIndexOp:
         assert index.table is not None
         return cls(
-            index.name,
+            index.name,  # type: ignore[arg-type]
             index.table.name,
-            index.expressions,
+            sqla_compat._get_index_expressions(index),
             schema=index.table.schema,
             unique=index.unique,
             **index.kwargs,
@@ -947,7 +926,7 @@ class CreateIndexOp(MigrateOperation):
         operations: Operations,
         index_name: Optional[str],
         table_name: str,
-        columns: Sequence[Union[str, TextClause, ColumnElement[Any]]],
+        columns: Sequence[Union[str, TextClause, Function[Any]]],
         *,
         schema: Optional[str] = None,
         unique: bool = False,
@@ -1075,7 +1054,6 @@ class DropIndexOp(MigrateOperation):
             table_name=index.table.name,
             schema=index.table.schema,
             _reverse=CreateIndexOp.from_index(index),
-            unique=index.unique,
             **index.kwargs,
         )
 
@@ -1173,7 +1151,6 @@ class CreateTableOp(MigrateOperation):
         columns: Sequence[SchemaItem],
         *,
         schema: Optional[str] = None,
-        if_not_exists: Optional[bool] = None,
         _namespace_metadata: Optional[MetaData] = None,
         _constraints_included: bool = False,
         **kw: Any,
@@ -1181,7 +1158,6 @@ class CreateTableOp(MigrateOperation):
         self.table_name = table_name
         self.columns = columns
         self.schema = schema
-        self.if_not_exists = if_not_exists
         self.info = kw.pop("info", {})
         self.comment = kw.pop("comment", None)
         self.prefixes = kw.pop("prefixes", None)
@@ -1206,7 +1182,7 @@ class CreateTableOp(MigrateOperation):
 
         return cls(
             table.name,
-            list(table.c) + list(table.constraints),
+            list(table.c) + list(table.constraints),  # type:ignore[arg-type]
             schema=table.schema,
             _namespace_metadata=_namespace_metadata,
             # given a Table() object, this Table will contain full Index()
@@ -1244,7 +1220,6 @@ class CreateTableOp(MigrateOperation):
         operations: Operations,
         table_name: str,
         *columns: SchemaItem,
-        if_not_exists: Optional[bool] = None,
         **kw: Any,
     ) -> Table:
         r"""Issue a "create table" instruction using the current migration
@@ -1317,10 +1292,6 @@ class CreateTableOp(MigrateOperation):
          quoting of the schema outside of the default behavior, use
          the SQLAlchemy construct
          :class:`~sqlalchemy.sql.elements.quoted_name`.
-        :param if_not_exists: If True, adds IF NOT EXISTS operator when
-         creating the new table.
-
-         .. versionadded:: 1.13.3
         :param \**kw: Other keyword arguments are passed to the underlying
          :class:`sqlalchemy.schema.Table` object created for the command.
 
@@ -1328,7 +1299,7 @@ class CreateTableOp(MigrateOperation):
          to the parameters given.
 
         """
-        op = cls(table_name, columns, if_not_exists=if_not_exists, **kw)
+        op = cls(table_name, columns, **kw)
         return operations.invoke(op)
 
 
@@ -1341,13 +1312,11 @@ class DropTableOp(MigrateOperation):
         table_name: str,
         *,
         schema: Optional[str] = None,
-        if_exists: Optional[bool] = None,
         table_kw: Optional[MutableMapping[Any, Any]] = None,
         _reverse: Optional[CreateTableOp] = None,
     ) -> None:
         self.table_name = table_name
         self.schema = schema
-        self.if_exists = if_exists
         self.table_kw = table_kw or {}
         self.comment = self.table_kw.pop("comment", None)
         self.info = self.table_kw.pop("info", None)
@@ -1394,9 +1363,9 @@ class DropTableOp(MigrateOperation):
             info=self.info.copy() if self.info else {},
             prefixes=list(self.prefixes) if self.prefixes else [],
             schema=self.schema,
-            _constraints_included=(
-                self._reverse._constraints_included if self._reverse else False
-            ),
+            _constraints_included=self._reverse._constraints_included
+            if self._reverse
+            else False,
             **self.table_kw,
         )
         return t
@@ -1408,7 +1377,6 @@ class DropTableOp(MigrateOperation):
         table_name: str,
         *,
         schema: Optional[str] = None,
-        if_exists: Optional[bool] = None,
         **kw: Any,
     ) -> None:
         r"""Issue a "drop table" instruction using the current
@@ -1424,15 +1392,11 @@ class DropTableOp(MigrateOperation):
          quoting of the schema outside of the default behavior, use
          the SQLAlchemy construct
          :class:`~sqlalchemy.sql.elements.quoted_name`.
-        :param if_exists: If True, adds IF EXISTS operator when
-         dropping the table.
-
-         .. versionadded:: 1.13.3
         :param \**kw: Other keyword arguments are passed to the underlying
          :class:`sqlalchemy.schema.Table` object created for the command.
 
         """
-        op = cls(table_name, schema=schema, if_exists=if_exists, table_kw=kw)
+        op = cls(table_name, schema=schema, table_kw=kw)
         operations.invoke(op)
 
 
@@ -1570,7 +1534,7 @@ class CreateTableCommentOp(AlterTableOp):
         )
         return operations.invoke(op)
 
-    def reverse(self) -> Union[CreateTableCommentOp, DropTableCommentOp]:
+    def reverse(self):
         """Reverses the COMMENT ON operation against a table."""
         if self.existing_comment is None:
             return DropTableCommentOp(
@@ -1586,16 +1550,14 @@ class CreateTableCommentOp(AlterTableOp):
                 schema=self.schema,
             )
 
-    def to_table(
-        self, migration_context: Optional[MigrationContext] = None
-    ) -> Table:
+    def to_table(self, migration_context=None):
         schema_obj = schemaobj.SchemaObjects(migration_context)
 
         return schema_obj.table(
             self.table_name, schema=self.schema, comment=self.comment
         )
 
-    def to_diff_tuple(self) -> Tuple[Any, ...]:
+    def to_diff_tuple(self):
         return ("add_table_comment", self.to_table(), self.existing_comment)
 
 
@@ -1667,20 +1629,18 @@ class DropTableCommentOp(AlterTableOp):
         )
         return operations.invoke(op)
 
-    def reverse(self) -> CreateTableCommentOp:
+    def reverse(self):
         """Reverses the COMMENT ON operation against a table."""
         return CreateTableCommentOp(
             self.table_name, self.existing_comment, schema=self.schema
         )
 
-    def to_table(
-        self, migration_context: Optional[MigrationContext] = None
-    ) -> Table:
+    def to_table(self, migration_context=None):
         schema_obj = schemaobj.SchemaObjects(migration_context)
 
         return schema_obj.table(self.table_name, schema=self.schema)
 
-    def to_diff_tuple(self) -> Tuple[Any, ...]:
+    def to_diff_tuple(self):
         return ("remove_table_comment", self.to_table())
 
 
@@ -1855,16 +1815,12 @@ class AlterColumnOp(AlterTableOp):
         *,
         nullable: Optional[bool] = None,
         comment: Optional[Union[str, Literal[False]]] = False,
-        server_default: Union[
-            str, bool, Identity, Computed, TextClause, None
-        ] = False,
+        server_default: Any = False,
         new_column_name: Optional[str] = None,
-        type_: Optional[Union[TypeEngine[Any], Type[TypeEngine[Any]]]] = None,
-        existing_type: Optional[
-            Union[TypeEngine[Any], Type[TypeEngine[Any]]]
-        ] = None,
-        existing_server_default: Union[
-            str, bool, Identity, Computed, TextClause, None
+        type_: Optional[Union[TypeEngine, Type[TypeEngine]]] = None,
+        existing_type: Optional[Union[TypeEngine, Type[TypeEngine]]] = None,
+        existing_server_default: Optional[
+            Union[str, bool, Identity, Computed]
         ] = False,
         existing_nullable: Optional[bool] = None,
         existing_comment: Optional[str] = None,
@@ -1982,10 +1938,8 @@ class AlterColumnOp(AlterTableOp):
         comment: Optional[Union[str, Literal[False]]] = False,
         server_default: Any = False,
         new_column_name: Optional[str] = None,
-        type_: Optional[Union[TypeEngine[Any], Type[TypeEngine[Any]]]] = None,
-        existing_type: Optional[
-            Union[TypeEngine[Any], Type[TypeEngine[Any]]]
-        ] = None,
+        type_: Optional[Union[TypeEngine, Type[TypeEngine]]] = None,
+        existing_type: Optional[Union[TypeEngine, Type[TypeEngine]]] = None,
         existing_server_default: Optional[
             Union[str, bool, Identity, Computed]
         ] = False,
@@ -2049,31 +2003,27 @@ class AddColumnOp(AlterTableOp):
         column: Column[Any],
         *,
         schema: Optional[str] = None,
-        if_not_exists: Optional[bool] = None,
         **kw: Any,
     ) -> None:
         super().__init__(table_name, schema=schema)
         self.column = column
-        self.if_not_exists = if_not_exists
         self.kw = kw
 
     def reverse(self) -> DropColumnOp:
-        op = DropColumnOp.from_column_and_tablename(
+        return DropColumnOp.from_column_and_tablename(
             self.schema, self.table_name, self.column
         )
-        op.if_exists = self.if_not_exists
-        return op
 
     def to_diff_tuple(
         self,
     ) -> Tuple[str, Optional[str], str, Column[Any]]:
         return ("add_column", self.schema, self.table_name, self.column)
 
-    def to_column(self) -> Column[Any]:
+    def to_column(self) -> Column:
         return self.column
 
     @classmethod
-    def from_column(cls, col: Column[Any]) -> AddColumnOp:
+    def from_column(cls, col: Column) -> AddColumnOp:
         return cls(col.table.name, col, schema=col.table.schema)
 
     @classmethod
@@ -2093,7 +2043,6 @@ class AddColumnOp(AlterTableOp):
         column: Column[Any],
         *,
         schema: Optional[str] = None,
-        if_not_exists: Optional[bool] = None,
     ) -> None:
         """Issue an "add column" instruction using the current
         migration context.
@@ -2170,19 +2119,10 @@ class AddColumnOp(AlterTableOp):
          quoting of the schema outside of the default behavior, use
          the SQLAlchemy construct
          :class:`~sqlalchemy.sql.elements.quoted_name`.
-        :param if_not_exists: If True, adds IF NOT EXISTS operator
-         when creating the new column for compatible dialects
-
-         .. versionadded:: 1.16.0
 
         """
 
-        op = cls(
-            table_name,
-            column,
-            schema=schema,
-            if_not_exists=if_not_exists,
-        )
+        op = cls(table_name, column, schema=schema)
         return operations.invoke(op)
 
     @classmethod
@@ -2193,7 +2133,6 @@ class AddColumnOp(AlterTableOp):
         *,
         insert_before: Optional[str] = None,
         insert_after: Optional[str] = None,
-        if_not_exists: Optional[bool] = None,
     ) -> None:
         """Issue an "add column" instruction using the current
         batch migration context.
@@ -2214,7 +2153,6 @@ class AddColumnOp(AlterTableOp):
             operations.impl.table_name,
             column,
             schema=operations.impl.schema,
-            if_not_exists=if_not_exists,
             **kw,
         )
         return operations.invoke(op)
@@ -2231,14 +2169,12 @@ class DropColumnOp(AlterTableOp):
         column_name: str,
         *,
         schema: Optional[str] = None,
-        if_exists: Optional[bool] = None,
         _reverse: Optional[AddColumnOp] = None,
         **kw: Any,
     ) -> None:
         super().__init__(table_name, schema=schema)
         self.column_name = column_name
         self.kw = kw
-        self.if_exists = if_exists
         self._reverse = _reverse
 
     def to_diff_tuple(
@@ -2258,11 +2194,9 @@ class DropColumnOp(AlterTableOp):
                 "original column is not present"
             )
 
-        op = AddColumnOp.from_column_and_tablename(
+        return AddColumnOp.from_column_and_tablename(
             self.schema, self.table_name, self._reverse.column
         )
-        op.if_not_exists = self.if_exists
-        return op
 
     @classmethod
     def from_column_and_tablename(
@@ -2280,7 +2214,7 @@ class DropColumnOp(AlterTableOp):
 
     def to_column(
         self, migration_context: Optional[MigrationContext] = None
-    ) -> Column[Any]:
+    ) -> Column:
         if self._reverse is not None:
             return self._reverse.column
         schema_obj = schemaobj.SchemaObjects(migration_context)
@@ -2309,11 +2243,6 @@ class DropColumnOp(AlterTableOp):
          quoting of the schema outside of the default behavior, use
          the SQLAlchemy construct
          :class:`~sqlalchemy.sql.elements.quoted_name`.
-        :param if_exists: If True, adds IF EXISTS operator when
-         dropping the new column for compatible dialects
-
-         .. versionadded:: 1.16.0
-
         :param mssql_drop_check: Optional boolean.  When ``True``, on
          Microsoft SQL Server only, first
          drop the CHECK constraint on the column using a
@@ -2335,6 +2264,7 @@ class DropColumnOp(AlterTableOp):
          then exec's a separate DROP CONSTRAINT for that default.  Only
          works if the column has exactly one FK constraint which refers to
          it, at the moment.
+
         """
 
         op = cls(table_name, column_name, schema=schema, **kw)
@@ -2368,7 +2298,7 @@ class BulkInsertOp(MigrateOperation):
     def __init__(
         self,
         table: Union[Table, TableClause],
-        rows: List[Dict[str, Any]],
+        rows: List[dict],
         *,
         multiinsert: bool = True,
     ) -> None:
@@ -2381,7 +2311,7 @@ class BulkInsertOp(MigrateOperation):
         cls,
         operations: Operations,
         table: Union[Table, TableClause],
-        rows: List[Dict[str, Any]],
+        rows: List[dict],
         *,
         multiinsert: bool = True,
     ) -> None:
@@ -2677,7 +2607,7 @@ class UpgradeOps(OpContainer):
         self.upgrade_token = upgrade_token
 
     def reverse_into(self, downgrade_ops: DowngradeOps) -> DowngradeOps:
-        downgrade_ops.ops[:] = list(
+        downgrade_ops.ops[:] = list(  # type:ignore[index]
             reversed([op.reverse() for op in self.ops])
         )
         return downgrade_ops
@@ -2704,7 +2634,7 @@ class DowngradeOps(OpContainer):
         super().__init__(ops=ops)
         self.downgrade_token = downgrade_token
 
-    def reverse(self) -> UpgradeOps:
+    def reverse(self):
         return UpgradeOps(
             ops=list(reversed([op.reverse() for op in self.ops]))
         )
@@ -2735,8 +2665,6 @@ class MigrationScript(MigrateOperation):
     """
 
     _needs_render: Optional[bool]
-    _upgrade_ops: List[UpgradeOps]
-    _downgrade_ops: List[DowngradeOps]
 
     def __init__(
         self,
@@ -2749,7 +2677,7 @@ class MigrationScript(MigrateOperation):
         head: Optional[str] = None,
         splice: Optional[bool] = None,
         branch_label: Optional[_RevIdType] = None,
-        version_path: Union[str, os.PathLike[str], None] = None,
+        version_path: Optional[str] = None,
         depends_on: Optional[_RevIdType] = None,
     ) -> None:
         self.rev_id = rev_id
@@ -2758,15 +2686,13 @@ class MigrationScript(MigrateOperation):
         self.head = head
         self.splice = splice
         self.branch_label = branch_label
-        self.version_path = (
-            pathlib.Path(version_path).as_posix() if version_path else None
-        )
+        self.version_path = version_path
         self.depends_on = depends_on
         self.upgrade_ops = upgrade_ops
         self.downgrade_ops = downgrade_ops
 
     @property
-    def upgrade_ops(self) -> Optional[UpgradeOps]:
+    def upgrade_ops(self):
         """An instance of :class:`.UpgradeOps`.
 
         .. seealso::
@@ -2785,15 +2711,13 @@ class MigrationScript(MigrateOperation):
             return self._upgrade_ops[0]
 
     @upgrade_ops.setter
-    def upgrade_ops(
-        self, upgrade_ops: Union[UpgradeOps, List[UpgradeOps]]
-    ) -> None:
+    def upgrade_ops(self, upgrade_ops):
         self._upgrade_ops = util.to_list(upgrade_ops)
         for elem in self._upgrade_ops:
             assert isinstance(elem, UpgradeOps)
 
     @property
-    def downgrade_ops(self) -> Optional[DowngradeOps]:
+    def downgrade_ops(self):
         """An instance of :class:`.DowngradeOps`.
 
         .. seealso::
@@ -2812,9 +2736,7 @@ class MigrationScript(MigrateOperation):
             return self._downgrade_ops[0]
 
     @downgrade_ops.setter
-    def downgrade_ops(
-        self, downgrade_ops: Union[DowngradeOps, List[DowngradeOps]]
-    ) -> None:
+    def downgrade_ops(self, downgrade_ops):
         self._downgrade_ops = util.to_list(downgrade_ops)
         for elem in self._downgrade_ops:
             assert isinstance(elem, DowngradeOps)

venv/lib/python3.12/site-packages/alembic/operations/schemaobj.py

@@ -1,6 +1,3 @@
-# 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
@@ -223,12 +220,10 @@ class SchemaObjects:
         t = sa_schema.Table(name, m, *cols, **kw)
 
         constraints = [
-            (
-                sqla_compat._copy(elem, target_table=t)
-                if getattr(elem, "parent", None) is not t
-                and getattr(elem, "parent", None) is not None
-                else elem
-            )
+            sqla_compat._copy(elem, target_table=t)
+            if getattr(elem, "parent", None) is not t
+            and getattr(elem, "parent", None) is not None
+            else elem
             for elem in columns
             if isinstance(elem, (Constraint, Index))
         ]
@@ -279,8 +274,10 @@ class SchemaObjects:
         ForeignKey.
 
         """
-        if isinstance(fk._colspec, str):
-            table_key, cname = fk._colspec.rsplit(".", 1)
+        if isinstance(fk._colspec, str):  # type:ignore[attr-defined]
+            table_key, cname = fk._colspec.rsplit(  # type:ignore[attr-defined]
+                ".", 1
+            )
             sname, tname = self._parse_table_key(table_key)
             if table_key not in metadata.tables:
                 rel_t = sa_schema.Table(tname, metadata, schema=sname)

venv/lib/python3.12/site-packages/alembic/operations/toimpl.py

@@ -1,6 +1,3 @@
-# mypy: allow-untyped-defs, allow-incomplete-defs, allow-untyped-calls
-# mypy: no-warn-return-any, allow-any-generics
-
 from typing import TYPE_CHECKING
 
 from sqlalchemy import schema as sa_schema
@@ -79,11 +76,8 @@ def alter_column(
 
 @Operations.implementation_for(ops.DropTableOp)
 def drop_table(operations: "Operations", operation: "ops.DropTableOp") -> None:
-    kw = {}
-    if operation.if_exists is not None:
-        kw["if_exists"] = operation.if_exists
     operations.impl.drop_table(
-        operation.to_table(operations.migration_context), **kw
+        operation.to_table(operations.migration_context)
     )
 
 
@@ -93,11 +87,7 @@ def drop_column(
 ) -> None:
     column = operation.to_column(operations.migration_context)
     operations.impl.drop_column(
-        operation.table_name,
-        column,
-        schema=operation.schema,
-        if_exists=operation.if_exists,
-        **operation.kw,
+        operation.table_name, column, schema=operation.schema, **operation.kw
     )
 
 
@@ -108,6 +98,9 @@ def create_index(
     idx = operation.to_index(operations.migration_context)
     kw = {}
     if operation.if_not_exists is not None:
+        if not sqla_2:
+            raise NotImplementedError("SQLAlchemy 2.0+ required")
+
         kw["if_not_exists"] = operation.if_not_exists
     operations.impl.create_index(idx, **kw)
 
@@ -116,6 +109,9 @@ def create_index(
 def drop_index(operations: "Operations", operation: "ops.DropIndexOp") -> None:
     kw = {}
     if operation.if_exists is not None:
+        if not sqla_2:
+            raise NotImplementedError("SQLAlchemy 2.0+ required")
+
         kw["if_exists"] = operation.if_exists
 
     operations.impl.drop_index(
@@ -128,11 +124,8 @@ def drop_index(operations: "Operations", operation: "ops.DropIndexOp") -> None:
 def create_table(
     operations: "Operations", operation: "ops.CreateTableOp"
 ) -> "Table":
-    kw = {}
-    if operation.if_not_exists is not None:
-        kw["if_not_exists"] = operation.if_not_exists
     table = operation.to_table(operations.migration_context)
-    operations.impl.create_table(table, **kw)
+    operations.impl.create_table(table)
     return table
 
 
@@ -172,13 +165,7 @@ def add_column(operations: "Operations", operation: "ops.AddColumnOp") -> None:
         column = _copy(column)
 
     t = operations.schema_obj.table(table_name, column, schema=schema)
-    operations.impl.add_column(
-        table_name,
-        column,
-        schema=schema,
-        if_not_exists=operation.if_not_exists,
-        **kw,
-    )
+    operations.impl.add_column(table_name, column, schema=schema, **kw)
 
     for constraint in t.constraints:
         if not isinstance(constraint, sa_schema.PrimaryKeyConstraint):
@@ -208,19 +195,13 @@ def create_constraint(
 def drop_constraint(
     operations: "Operations", operation: "ops.DropConstraintOp"
 ) -> None:
-    kw = {}
-    if operation.if_exists is not None:
-        if not sqla_2:
-            raise NotImplementedError("SQLAlchemy 2.0 required")
-        kw["if_exists"] = operation.if_exists
     operations.impl.drop_constraint(
         operations.schema_obj.generic_constraint(
             operation.constraint_name,
             operation.table_name,
             operation.constraint_type,
             schema=operation.schema,
-        ),
-        **kw,
+        )
     )