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

alembic/autogenerate/render.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from collections import OrderedDict
 from io import StringIO
 import re
 from typing import Any
@@ -165,14 +164,22 @@ def _render_modify_table(
 def _render_create_table_comment(
     autogen_context: AutogenContext, op: ops.CreateTableCommentOp
 ) -> str:
-    templ = (
-        "{prefix}create_table_comment(\n"
-        "{indent}'{tname}',\n"
-        "{indent}{comment},\n"
-        "{indent}existing_comment={existing},\n"
-        "{indent}schema={schema}\n"
-        ")"
-    )
+    if autogen_context._has_batch:
+        templ = (
+            "{prefix}create_table_comment(\n"
+            "{indent}{comment},\n"
+            "{indent}existing_comment={existing}\n"
+            ")"
+        )
+    else:
+        templ = (
+            "{prefix}create_table_comment(\n"
+            "{indent}'{tname}',\n"
+            "{indent}{comment},\n"
+            "{indent}existing_comment={existing},\n"
+            "{indent}schema={schema}\n"
+            ")"
+        )
     return templ.format(
         prefix=_alembic_autogenerate_prefix(autogen_context),
         tname=op.table_name,
@@ -189,13 +196,20 @@ def _render_create_table_comment(
 def _render_drop_table_comment(
     autogen_context: AutogenContext, op: ops.DropTableCommentOp
 ) -> str:
-    templ = (
-        "{prefix}drop_table_comment(\n"
-        "{indent}'{tname}',\n"
-        "{indent}existing_comment={existing},\n"
-        "{indent}schema={schema}\n"
-        ")"
-    )
+    if autogen_context._has_batch:
+        templ = (
+            "{prefix}drop_table_comment(\n"
+            "{indent}existing_comment={existing}\n"
+            ")"
+        )
+    else:
+        templ = (
+            "{prefix}drop_table_comment(\n"
+            "{indent}'{tname}',\n"
+            "{indent}existing_comment={existing},\n"
+            "{indent}schema={schema}\n"
+            ")"
+        )
     return templ.format(
         prefix=_alembic_autogenerate_prefix(autogen_context),
         tname=op.table_name,
@@ -246,6 +260,11 @@ def _add_table(autogen_context: AutogenContext, op: ops.CreateTableOp) -> str:
     comment = table.comment
     if comment:
         text += ",\ncomment=%r" % _ident(comment)
+
+    info = table.info
+    if info:
+        text += f",\ninfo={info!r}"
+
     for k in sorted(op.kw):
         text += ",\n%s=%r" % (k.replace(" ", "_"), op.kw[k])
 
@@ -544,8 +563,10 @@ def _ident(name: Optional[Union[quoted_name, str]]) -> Optional[str]:
 def _render_potential_expr(
     value: Any,
     autogen_context: AutogenContext,
+    *,
     wrap_in_text: bool = True,
     is_server_default: bool = False,
+    is_index: bool = False,
 ) -> str:
     if isinstance(value, sql.ClauseElement):
         if wrap_in_text:
@@ -556,7 +577,7 @@ def _render_potential_expr(
         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
+                value, is_server_default=is_server_default, is_index=is_index
             ),
         }
 
@@ -570,7 +591,7 @@ def _get_index_rendered_expressions(
     return [
         repr(_ident(getattr(exp, "name", None)))
         if isinstance(exp, sa_schema.Column)
-        else _render_potential_expr(exp, autogen_context)
+        else _render_potential_expr(exp, autogen_context, is_index=True)
         for exp in idx.expressions
     ]
 
@@ -760,11 +781,9 @@ def _render_computed(
 def _render_identity(
     identity: Identity, autogen_context: AutogenContext
 ) -> str:
-    # always=None means something different than always=False
-    kwargs = OrderedDict(always=identity.always)
-    if identity.on_null is not None:
-        kwargs["on_null"] = identity.on_null
-    kwargs.update(_get_identity_options(identity))
+    kwargs = sqla_compat._get_identity_options_dict(
+        identity, dialect_kwargs=True
+    )
 
     return "%(prefix)sIdentity(%(kwargs)s)" % {
         "prefix": _sqlalchemy_autogenerate_prefix(autogen_context),
@@ -772,15 +791,6 @@ def _render_identity(
     }
 
 
-def _get_identity_options(identity_options: Identity) -> OrderedDict:
-    kwargs = OrderedDict()
-    for attr in sqla_compat._identity_options_attrs:
-        value = getattr(identity_options, attr, None)
-        if value is not None:
-            kwargs[attr] = value
-    return kwargs
-
-
 def _repr_type(
     type_: TypeEngine,
     autogen_context: AutogenContext,

alembic/autogenerate/rewriter.py

@@ -9,19 +9,19 @@ from typing import Type
 from typing import TYPE_CHECKING
 from typing import Union
 
-from alembic import util
-from alembic.operations import ops
+from .. import util
+from ..operations import ops
 
 if TYPE_CHECKING:
-    from alembic.operations.ops import AddColumnOp
-    from alembic.operations.ops import AlterColumnOp
-    from alembic.operations.ops import CreateTableOp
-    from alembic.operations.ops import MigrateOperation
-    from alembic.operations.ops import MigrationScript
-    from alembic.operations.ops import ModifyTableOps
-    from alembic.operations.ops import OpContainer
-    from alembic.runtime.migration import MigrationContext
-    from alembic.script.revision import Revision
+    from ..operations.ops import AddColumnOp
+    from ..operations.ops import AlterColumnOp
+    from ..operations.ops import CreateTableOp
+    from ..operations.ops import MigrateOperation
+    from ..operations.ops import MigrationScript
+    from ..operations.ops import ModifyTableOps
+    from ..operations.ops import OpContainer
+    from ..runtime.environment import _GetRevArg
+    from ..runtime.migration import MigrationContext
 
 
 class Rewriter:
@@ -119,7 +119,7 @@ class Rewriter:
     def _rewrite(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directive: MigrateOperation,
     ) -> Iterator[MigrateOperation]:
         try:
@@ -142,7 +142,7 @@ class Rewriter:
     def __call__(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directives: List[MigrationScript],
     ) -> None:
         self.process_revision_directives(context, revision, directives)
@@ -153,7 +153,7 @@ class Rewriter:
     def _traverse_script(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directive: MigrationScript,
     ) -> None:
         upgrade_ops_list = []
@@ -180,7 +180,7 @@ class Rewriter:
     def _traverse_op_container(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directive: OpContainer,
     ) -> None:
         self._traverse_list(context, revision, directive.ops)
@@ -189,7 +189,7 @@ class Rewriter:
     def _traverse_any_directive(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directive: MigrateOperation,
     ) -> None:
         pass
@@ -197,7 +197,7 @@ class Rewriter:
     def _traverse_for(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directive: MigrateOperation,
     ) -> Any:
         directives = list(self._rewrite(context, revision, directive))
@@ -209,7 +209,7 @@ class Rewriter:
     def _traverse_list(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directives: Any,
     ) -> None:
         dest = []
@@ -221,7 +221,7 @@ class Rewriter:
     def process_revision_directives(
         self,
         context: MigrationContext,
-        revision: Revision,
+        revision: _GetRevArg,
         directives: List[MigrationScript],
     ) -> None:
         self._traverse_list(context, revision, directives)

alembic/command.py

@@ -14,6 +14,7 @@ from .script import ScriptDirectory
 if TYPE_CHECKING:
     from alembic.config import Config
     from alembic.script.base import Script
+    from alembic.script.revision import _RevIdType
     from .runtime.environment import ProcessRevisionDirectiveFn
 
 
@@ -105,7 +106,7 @@ def init(
             os.path.join(os.path.abspath(directory), "__init__.py"),
             os.path.join(os.path.abspath(versions), "__init__.py"),
         ]:
-            with util.status("Adding {path!r}", **config.messaging_opts):
+            with util.status(f"Adding {path!r}", **config.messaging_opts):
                 with open(path, "w"):
                     pass
 
@@ -124,7 +125,7 @@ def revision(
     sql: bool = False,
     head: str = "head",
     splice: bool = False,
-    branch_label: Optional[str] = None,
+    branch_label: Optional[_RevIdType] = None,
     version_path: Optional[str] = None,
     rev_id: Optional[str] = None,
     depends_on: Optional[str] = None,
@@ -244,9 +245,7 @@ def revision(
         return scripts
 
 
-def check(
-    config: "Config",
-) -> None:
+def check(config: "Config") -> None:
     """Check if revision command with autogenerate has pending upgrade ops.
 
     :param config: a :class:`.Config` object.
@@ -291,7 +290,10 @@ def check(
     # the revision_context now has MigrationScript structure(s) present.
 
     migration_script = revision_context.generated_revisions[-1]
-    diffs = migration_script.upgrade_ops.as_diffs()
+    diffs = []
+    for upgrade_ops in migration_script.upgrade_ops_list:
+        diffs.extend(upgrade_ops.as_diffs())
+
     if diffs:
         raise util.AutogenerateDiffsDetected(
             f"New upgrade operations detected: {diffs}"
@@ -302,9 +304,9 @@ def check(
 
 def merge(
     config: Config,
-    revisions: str,
+    revisions: _RevIdType,
     message: Optional[str] = None,
-    branch_label: Optional[str] = None,
+    branch_label: Optional[_RevIdType] = None,
     rev_id: Optional[str] = None,
 ) -> Optional[Script]:
     """Merge two revisions together.  Creates a new migration file.
@@ -623,7 +625,7 @@ def current(config: Config, verbose: bool = False) -> None:
 
 def stamp(
     config: Config,
-    revision: str,
+    revision: _RevIdType,
     sql: bool = False,
     tag: Optional[str] = None,
     purge: bool = False,

alembic/config.py

@@ -34,7 +34,7 @@ class Config:
 
         some_param = context.config.get_main_option("my option")
 
-    When invoking Alembic programatically, a new
+    When invoking Alembic programmatically, a new
     :class:`.Config` can be created by passing
     the name of an .ini file to the constructor::
 

alembic/context.pyi

@@ -7,12 +7,14 @@ from typing import Callable
 from typing import Collection
 from typing import ContextManager
 from typing import Dict
+from typing import Iterable
 from typing import List
 from typing import Literal
 from typing import Mapping
 from typing import MutableMapping
 from typing import Optional
 from typing import overload
+from typing import Sequence
 from typing import TextIO
 from typing import Tuple
 from typing import TYPE_CHECKING
@@ -21,7 +23,7 @@ from typing import Union
 if TYPE_CHECKING:
     from sqlalchemy.engine.base import Connection
     from sqlalchemy.engine.url import URL
-    from sqlalchemy.sql.elements import ClauseElement
+    from sqlalchemy.sql import Executable
     from sqlalchemy.sql.schema import Column
     from sqlalchemy.sql.schema import FetchedValue
     from sqlalchemy.sql.schema import MetaData
@@ -30,7 +32,7 @@ if TYPE_CHECKING:
 
     from .autogenerate.api import AutogenContext
     from .config import Config
-    from .operations.ops import MigrateOperation
+    from .operations.ops import MigrationScript
     from .runtime.migration import _ProxyTransaction
     from .runtime.migration import MigrationContext
     from .runtime.migration import MigrationInfo
@@ -96,7 +98,7 @@ def configure(
     tag: Optional[str] = None,
     template_args: Optional[Dict[str, Any]] = None,
     render_as_batch: bool = False,
-    target_metadata: Optional[MetaData] = None,
+    target_metadata: Union[MetaData, Sequence[MetaData], None] = None,
     include_name: Optional[
         Callable[
             [
@@ -143,7 +145,12 @@ def configure(
     include_schemas: bool = False,
     process_revision_directives: Optional[
         Callable[
-            [MigrationContext, Tuple[str, str], List[MigrateOperation]], None
+            [
+                MigrationContext,
+                Union[str, Iterable[Optional[str]], Iterable[str]],
+                List[MigrationScript],
+            ],
+            None,
         ]
     ] = None,
     compare_type: Union[
@@ -629,7 +636,7 @@ def configure(
     """
 
 def execute(
-    sql: Union[ClauseElement, str], execution_options: Optional[dict] = None
+    sql: Union[Executable, str], execution_options: Optional[dict] = None
 ) -> None:
     """Execute the given SQL using the current change context.
 

alembic/ddl/_autogen.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+from typing import Any
+from typing import ClassVar
+from typing import Dict
+from typing import Generic
+from typing import NamedTuple
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
+from typing import Type
+from typing import TYPE_CHECKING
+from typing import TypeVar
+from typing import Union
+
+from sqlalchemy.sql.schema import Constraint
+from sqlalchemy.sql.schema import ForeignKeyConstraint
+from sqlalchemy.sql.schema import Index
+from sqlalchemy.sql.schema import UniqueConstraint
+from typing_extensions import TypeGuard
+
+from alembic.ddl.base import _fk_spec
+from .. import util
+from ..util import sqla_compat
+
+if TYPE_CHECKING:
+    from typing import Literal
+
+    from alembic.autogenerate.api import AutogenContext
+    from alembic.ddl.impl import DefaultImpl
+
+CompareConstraintType = Union[Constraint, Index]
+
+_C = TypeVar("_C", bound=CompareConstraintType)
+
+_clsreg: Dict[str, Type[_constraint_sig]] = {}
+
+
+class ComparisonResult(NamedTuple):
+    status: Literal["equal", "different", "skip"]
+    message: str
+
+    @property
+    def is_equal(self) -> bool:
+        return self.status == "equal"
+
+    @property
+    def is_different(self) -> bool:
+        return self.status == "different"
+
+    @property
+    def is_skip(self) -> bool:
+        return self.status == "skip"
+
+    @classmethod
+    def Equal(cls) -> ComparisonResult:
+        """the constraints are equal."""
+        return cls("equal", "The two constraints are equal")
+
+    @classmethod
+    def Different(cls, reason: Union[str, Sequence[str]]) -> ComparisonResult:
+        """the constraints are different for the provided reason(s)."""
+        return cls("different", ", ".join(util.to_list(reason)))
+
+    @classmethod
+    def Skip(cls, reason: Union[str, Sequence[str]]) -> ComparisonResult:
+        """the constraint cannot be compared for the provided reason(s).
+
+        The message is logged, but the constraints will be otherwise
+        considered equal, meaning that no migration command will be
+        generated.
+        """
+        return cls("skip", ", ".join(util.to_list(reason)))
+
+
+class _constraint_sig(Generic[_C]):
+    const: _C
+
+    _sig: Tuple[Any, ...]
+    name: Optional[sqla_compat._ConstraintNameDefined]
+
+    impl: DefaultImpl
+
+    _is_index: ClassVar[bool] = False
+    _is_fk: ClassVar[bool] = False
+    _is_uq: ClassVar[bool] = False
+
+    _is_metadata: bool
+
+    def __init_subclass__(cls) -> None:
+        cls._register()
+
+    @classmethod
+    def _register(cls):
+        raise NotImplementedError()
+
+    def __init__(
+        self, is_metadata: bool, impl: DefaultImpl, const: _C
+    ) -> None:
+        raise NotImplementedError()
+
+    def compare_to_reflected(
+        self, other: _constraint_sig[Any]
+    ) -> ComparisonResult:
+        assert self.impl is other.impl
+        assert self._is_metadata
+        assert not other._is_metadata
+
+        return self._compare_to_reflected(other)
+
+    def _compare_to_reflected(
+        self, other: _constraint_sig[_C]
+    ) -> ComparisonResult:
+        raise NotImplementedError()
+
+    @classmethod
+    def from_constraint(
+        cls, is_metadata: bool, impl: DefaultImpl, constraint: _C
+    ) -> _constraint_sig[_C]:
+        # these could be cached by constraint/impl, however, if the
+        # constraint is modified in place, then the sig is wrong.  the mysql
+        # impl currently does this, and if we fixed that we can't be sure
+        # someone else might do it too, so play it safe.
+        sig = _clsreg[constraint.__visit_name__](is_metadata, impl, constraint)
+        return sig
+
+    def md_name_to_sql_name(self, context: AutogenContext) -> Optional[str]:
+        return sqla_compat._get_constraint_final_name(
+            self.const, context.dialect
+        )
+
+    @util.memoized_property
+    def is_named(self):
+        return sqla_compat._constraint_is_named(self.const, self.impl.dialect)
+
+    @util.memoized_property
+    def unnamed(self) -> Tuple[Any, ...]:
+        return self._sig
+
+    @util.memoized_property
+    def unnamed_no_options(self) -> Tuple[Any, ...]:
+        raise NotImplementedError()
+
+    @util.memoized_property
+    def _full_sig(self) -> Tuple[Any, ...]:
+        return (self.name,) + self.unnamed
+
+    def __eq__(self, other) -> bool:
+        return self._full_sig == other._full_sig
+
+    def __ne__(self, other) -> bool:
+        return self._full_sig != other._full_sig
+
+    def __hash__(self) -> int:
+        return hash(self._full_sig)
+
+
+class _uq_constraint_sig(_constraint_sig[UniqueConstraint]):
+    _is_uq = True
+
+    @classmethod
+    def _register(cls) -> None:
+        _clsreg["unique_constraint"] = cls
+
+    is_unique = True
+
+    def __init__(
+        self,
+        is_metadata: bool,
+        impl: DefaultImpl,
+        const: UniqueConstraint,
+    ) -> None:
+        self.impl = impl
+        self.const = const
+        self.name = sqla_compat.constraint_name_or_none(const.name)
+        self._sig = tuple(sorted([col.name for col in const.columns]))
+        self._is_metadata = is_metadata
+
+    @property
+    def column_names(self) -> Tuple[str, ...]:
+        return tuple([col.name for col in self.const.columns])
+
+    def _compare_to_reflected(
+        self, other: _constraint_sig[_C]
+    ) -> ComparisonResult:
+        assert self._is_metadata
+        metadata_obj = self
+        conn_obj = other
+
+        assert is_uq_sig(conn_obj)
+        return self.impl.compare_unique_constraint(
+            metadata_obj.const, conn_obj.const
+        )
+
+
+class _ix_constraint_sig(_constraint_sig[Index]):
+    _is_index = True
+
+    name: sqla_compat._ConstraintName
+
+    @classmethod
+    def _register(cls) -> None:
+        _clsreg["index"] = cls
+
+    def __init__(
+        self, is_metadata: bool, impl: DefaultImpl, const: Index
+    ) -> None:
+        self.impl = impl
+        self.const = const
+        self.name = const.name
+        self.is_unique = bool(const.unique)
+        self._is_metadata = is_metadata
+
+    def _compare_to_reflected(
+        self, other: _constraint_sig[_C]
+    ) -> ComparisonResult:
+        assert self._is_metadata
+        metadata_obj = self
+        conn_obj = other
+
+        assert is_index_sig(conn_obj)
+        return self.impl.compare_indexes(metadata_obj.const, conn_obj.const)
+
+    @util.memoized_property
+    def has_expressions(self):
+        return sqla_compat.is_expression_index(self.const)
+
+    @util.memoized_property
+    def column_names(self) -> Tuple[str, ...]:
+        return tuple([col.name for col in self.const.columns])
+
+    @util.memoized_property
+    def column_names_optional(self) -> Tuple[Optional[str], ...]:
+        return tuple(
+            [getattr(col, "name", None) for col in self.const.expressions]
+        )
+
+    @util.memoized_property
+    def is_named(self):
+        return True
+
+    @util.memoized_property
+    def unnamed(self):
+        return (self.is_unique,) + self.column_names_optional
+
+
+class _fk_constraint_sig(_constraint_sig[ForeignKeyConstraint]):
+    _is_fk = True
+
+    @classmethod
+    def _register(cls) -> None:
+        _clsreg["foreign_key_constraint"] = cls
+
+    def __init__(
+        self,
+        is_metadata: bool,
+        impl: DefaultImpl,
+        const: ForeignKeyConstraint,
+    ) -> None:
+        self._is_metadata = is_metadata
+
+        self.impl = impl
+        self.const = const
+
+        self.name = sqla_compat.constraint_name_or_none(const.name)
+
+        (
+            self.source_schema,
+            self.source_table,
+            self.source_columns,
+            self.target_schema,
+            self.target_table,
+            self.target_columns,
+            onupdate,
+            ondelete,
+            deferrable,
+            initially,
+        ) = _fk_spec(const)
+
+        self._sig: Tuple[Any, ...] = (
+            self.source_schema,
+            self.source_table,
+            tuple(self.source_columns),
+            self.target_schema,
+            self.target_table,
+            tuple(self.target_columns),
+        ) + (
+            (None if onupdate.lower() == "no action" else onupdate.lower())
+            if onupdate
+            else None,
+            (None if ondelete.lower() == "no action" else ondelete.lower())
+            if ondelete
+            else None,
+            # convert initially + deferrable into one three-state value
+            "initially_deferrable"
+            if initially and initially.lower() == "deferred"
+            else "deferrable"
+            if deferrable
+            else "not deferrable",
+        )
+
+    @util.memoized_property
+    def unnamed_no_options(self):
+        return (
+            self.source_schema,
+            self.source_table,
+            tuple(self.source_columns),
+            self.target_schema,
+            self.target_table,
+            tuple(self.target_columns),
+        )
+
+
+def is_index_sig(sig: _constraint_sig) -> TypeGuard[_ix_constraint_sig]:
+    return sig._is_index
+
+
+def is_uq_sig(sig: _constraint_sig) -> TypeGuard[_uq_constraint_sig]:
+    return sig._is_uq
+
+
+def is_fk_sig(sig: _constraint_sig) -> TypeGuard[_fk_constraint_sig]:
+    return sig._is_fk