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

alembic/runtime/migration.py

@@ -40,7 +40,7 @@ if TYPE_CHECKING:
     from sqlalchemy.engine.base import Connection
     from sqlalchemy.engine.base import Transaction
     from sqlalchemy.engine.mock import MockConnection
-    from sqlalchemy.sql.elements import ClauseElement
+    from sqlalchemy.sql import Executable
 
     from .environment import EnvironmentContext
     from ..config import Config
@@ -651,7 +651,7 @@ class MigrationContext:
 
     def execute(
         self,
-        sql: Union[ClauseElement, str],
+        sql: Union[Executable, str],
         execution_options: Optional[dict] = None,
     ) -> None:
         """Execute a SQL construct or string statement.
@@ -1157,7 +1157,7 @@ class RevisionStep(MigrationStep):
             self.to_revisions[0],
         )
 
-    def _unmerge_to_revisions(self, heads: Collection[str]) -> Tuple[str, ...]:
+    def _unmerge_to_revisions(self, heads: Set[str]) -> Tuple[str, ...]:
         other_heads = set(heads).difference([self.revision.revision])
         if other_heads:
             ancestors = {
@@ -1171,7 +1171,7 @@ class RevisionStep(MigrationStep):
             return self.to_revisions
 
     def unmerge_branch_idents(
-        self, heads: Collection[str]
+        self, heads: Set[str]
     ) -> Tuple[str, str, Tuple[str, ...]]:
         to_revisions = self._unmerge_to_revisions(heads)
 

alembic/script/base.py

@@ -23,9 +23,11 @@ from . import revision
 from . import write_hooks
 from .. import util
 from ..runtime import migration
+from ..util import compat
 from ..util import not_none
 
 if TYPE_CHECKING:
+    from .revision import _GetRevArg
     from .revision import _RevIdType
     from .revision import Revision
     from ..config import Config
@@ -34,9 +36,14 @@ if TYPE_CHECKING:
     from ..runtime.migration import StampStep
 
 try:
-    from dateutil import tz
+    if compat.py39:
+        from zoneinfo import ZoneInfo
+        from zoneinfo import ZoneInfoNotFoundError
+    else:
+        from backports.zoneinfo import ZoneInfo  # type: ignore[import-not-found,no-redef] # noqa: E501
+        from backports.zoneinfo import ZoneInfoNotFoundError  # type: ignore[import-not-found,no-redef] # noqa: E501
 except ImportError:
-    tz = None  # type: ignore[assignment]
+    ZoneInfo = None  # type: ignore[assignment, misc]
 
 _sourceless_rev_file = re.compile(r"(?!\.\#|__init__)(.*\.py)(c|o)?$")
 _only_source_rev_file = re.compile(r"(?!\.\#|__init__)(.*\.py)$")
@@ -296,7 +303,7 @@ class ScriptDirectory:
             ):
                 yield cast(Script, rev)
 
-    def get_revisions(self, id_: _RevIdType) -> Tuple[Optional[Script], ...]:
+    def get_revisions(self, id_: _GetRevArg) -> Tuple[Optional[Script], ...]:
         """Return the :class:`.Script` instance with the given rev identifier,
         symbolic name, or sequence of identifiers.
 
@@ -603,23 +610,26 @@ class ScriptDirectory:
 
     def _generate_create_date(self) -> datetime.datetime:
         if self.timezone is not None:
-            if tz is None:
+            if ZoneInfo is None:
                 raise util.CommandError(
-                    "The library 'python-dateutil' is required "
-                    "for timezone support"
+                    "Python >= 3.9 is required for timezone support or"
+                    "the 'backports.zoneinfo' package must be installed."
                 )
             # First, assume correct capitalization
-            tzinfo = tz.gettz(self.timezone)
-            if tzinfo is None:
-                # Fall back to uppercase
-                tzinfo = tz.gettz(self.timezone.upper())
+            try:
+                tzinfo = ZoneInfo(self.timezone)
+            except ZoneInfoNotFoundError:
+                tzinfo = None
             if tzinfo is None:
-                raise util.CommandError(
-                    "Can't locate timezone: %s" % self.timezone
-                )
+                try:
+                    tzinfo = ZoneInfo(self.timezone.upper())
+                except ZoneInfoNotFoundError:
+                    raise util.CommandError(
+                        "Can't locate timezone: %s" % self.timezone
+                    ) from None
             create_date = (
                 datetime.datetime.utcnow()
-                .replace(tzinfo=tz.tzutc())
+                .replace(tzinfo=datetime.timezone.utc)
                 .astimezone(tzinfo)
             )
         else:
@@ -630,8 +640,7 @@ class ScriptDirectory:
         self,
         revid: str,
         message: Optional[str],
-        head: Optional[str] = None,
-        refresh: bool = False,
+        head: Optional[_RevIdType] = None,
         splice: Optional[bool] = False,
         branch_labels: Optional[_RevIdType] = None,
         version_path: Optional[str] = None,
@@ -653,7 +662,6 @@ class ScriptDirectory:
         :param splice: if True, allow the "head" version to not be an
          actual head; otherwise, the selected head must be a head
          (e.g. endpoint) revision.
-        :param refresh: deprecated.
 
         """
         if head is None:

alembic/script/revision.py

@@ -29,13 +29,19 @@ from ..util import not_none
 if TYPE_CHECKING:
     from typing import Literal
 
-_RevIdType = Union[str, Sequence[str]]
+_RevIdType = Union[str, List[str], Tuple[str, ...]]
+_GetRevArg = Union[
+    str,
+    Iterable[Optional[str]],
+    Iterable[str],
+]
 _RevisionIdentifierType = Union[str, Tuple[str, ...], None]
 _RevisionOrStr = Union["Revision", str]
 _RevisionOrBase = Union["Revision", "Literal['base']"]
 _InterimRevisionMapType = Dict[str, "Revision"]
 _RevisionMapType = Dict[Union[None, str, Tuple[()]], Optional["Revision"]]
-_T = TypeVar("_T", bound=Union[str, "Revision"])
+_T = TypeVar("_T")
+_TR = TypeVar("_TR", bound=Optional[_RevisionOrStr])
 
 _relative_destination = re.compile(r"(?:(.+?)@)?(\w+)?((?:\+|-)\d+)")
 _revision_illegal_chars = ["@", "-", "+"]
@@ -501,7 +507,7 @@ class RevisionMap:
         return self.filter_for_lineage(self.bases, identifier)
 
     def get_revisions(
-        self, id_: Union[str, Collection[Optional[str]], None]
+        self, id_: Optional[_GetRevArg]
     ) -> Tuple[Optional[_RevisionOrBase], ...]:
         """Return the :class:`.Revision` instances with the given rev id
         or identifiers.
@@ -523,9 +529,7 @@ class RevisionMap:
         if isinstance(id_, (list, tuple, set, frozenset)):
             return sum([self.get_revisions(id_elem) for id_elem in id_], ())
         else:
-            resolved_id, branch_label = self._resolve_revision_number(
-                id_  # type:ignore [arg-type]
-            )
+            resolved_id, branch_label = self._resolve_revision_number(id_)
             if len(resolved_id) == 1:
                 try:
                     rint = int(resolved_id[0])
@@ -590,7 +594,7 @@ class RevisionMap:
 
     def _revision_for_ident(
         self,
-        resolved_id: Union[str, Tuple[()]],
+        resolved_id: Union[str, Tuple[()], None],
         check_branch: Optional[str] = None,
     ) -> Optional[Revision]:
         branch_rev: Optional[Revision]
@@ -669,10 +673,10 @@ class RevisionMap:
 
     def filter_for_lineage(
         self,
-        targets: Iterable[_T],
+        targets: Iterable[_TR],
         check_against: Optional[str],
         include_dependencies: bool = False,
-    ) -> Tuple[_T, ...]:
+    ) -> Tuple[_TR, ...]:
         id_, branch_label = self._resolve_revision_number(check_against)
 
         shares = []
@@ -691,7 +695,7 @@ class RevisionMap:
 
     def _shares_lineage(
         self,
-        target: _RevisionOrStr,
+        target: Optional[_RevisionOrStr],
         test_against_revs: Sequence[_RevisionOrStr],
         include_dependencies: bool = False,
     ) -> bool:
@@ -728,7 +732,7 @@ class RevisionMap:
         )
 
     def _resolve_revision_number(
-        self, id_: Optional[str]
+        self, id_: Optional[_GetRevArg]
     ) -> Tuple[Tuple[str, ...], Optional[str]]:
         branch_label: Optional[str]
         if isinstance(id_, str) and "@" in id_:
@@ -1080,13 +1084,13 @@ class RevisionMap:
     ) -> Tuple[Optional[str], Optional[_RevisionOrBase]]:
         """
         Parse downgrade command syntax :target to retrieve the target revision
-        and branch label (if any) given the :current_revisons stamp of the
+        and branch label (if any) given the :current_revisions stamp of the
         database.
 
         Returns a tuple (branch_label, target_revision) where branch_label
         is a string from the command specifying the branch to consider (or
         None if no branch given), and target_revision is a Revision object
-        which the command refers to. target_revsions is None if the command
+        which the command refers to. target_revisions is None if the command
         refers to 'base'. The target may be specified in absolute form, or
         relative to :current_revisions.
         """
@@ -1129,7 +1133,7 @@ class RevisionMap:
                         if not symbol_list:
                             # check the case where there are multiple branches
                             # but there is currently a single heads, since all
-                            # other branch heads are dependant of the current
+                            # other branch heads are dependent of the current
                             # single heads.
                             all_current = cast(
                                 Set[Revision], self._get_all_current(cr_tuple)
@@ -1196,7 +1200,7 @@ class RevisionMap:
     ) -> Tuple[Optional[_RevisionOrBase], ...]:
         """
         Parse upgrade command syntax :target to retrieve the target revision
-        and given the :current_revisons stamp of the database.
+        and given the :current_revisions stamp of the database.
 
         Returns a tuple of Revision objects which should be iterated/upgraded
         to. The target may be specified in absolute form, or relative to
@@ -1211,7 +1215,7 @@ class RevisionMap:
             # No relative destination, target is absolute.
             return self.get_revisions(target)
 
-        current_revisions_tup: Union[str, Collection[Optional[str]], None]
+        current_revisions_tup: Union[str, Tuple[Optional[str], ...], None]
         current_revisions_tup = util.to_tuple(current_revisions)
 
         branch_label, symbol, relative_str = match.groups()
@@ -1224,7 +1228,8 @@ class RevisionMap:
                 start_revs = current_revisions_tup
                 if branch_label:
                     start_revs = self.filter_for_lineage(
-                        self.get_revisions(current_revisions_tup), branch_label
+                        self.get_revisions(current_revisions_tup),  # type: ignore[arg-type] # noqa: E501
+                        branch_label,
                     )
                     if not start_revs:
                         # The requested branch is not a head, so we need to
@@ -1577,8 +1582,8 @@ class Revision:
 
         self.verify_rev_id(revision)
         self.revision = revision
-        self.down_revision = tuple_rev_as_scalar(down_revision)
-        self.dependencies = tuple_rev_as_scalar(dependencies)
+        self.down_revision = tuple_rev_as_scalar(util.to_tuple(down_revision))
+        self.dependencies = tuple_rev_as_scalar(util.to_tuple(dependencies))
         self._orig_branch_labels = util.to_tuple(branch_labels, default=())
         self.branch_labels = set(self._orig_branch_labels)
 
@@ -1676,20 +1681,20 @@ class Revision:
 
 
 @overload
-def tuple_rev_as_scalar(
-    rev: Optional[Sequence[str]],
-) -> Optional[Union[str, Sequence[str]]]:
+def tuple_rev_as_scalar(rev: None) -> None:
     ...
 
 
 @overload
 def tuple_rev_as_scalar(
-    rev: Optional[Sequence[Optional[str]]],
-) -> Optional[Union[Optional[str], Sequence[Optional[str]]]]:
+    rev: Union[Tuple[_T, ...], List[_T]]
+) -> Union[_T, Tuple[_T, ...], List[_T]]:
     ...
 
 
-def tuple_rev_as_scalar(rev):
+def tuple_rev_as_scalar(
+    rev: Optional[Sequence[_T]],
+) -> Union[_T, Sequence[_T], None]:
     if not rev:
         return None
     elif len(rev) == 1:

alembic/templates/async/alembic.ini.mako

@@ -14,9 +14,9 @@ prepend_sys_path = .
 
 # timezone to use when rendering the date within the migration file
 # as well as the filename.
-# If specified, requires the python-dateutil library that can be
-# installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to dateutil.tz.gettz()
+# If specified, requires the python>=3.9 or backports.zoneinfo library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
 # leave blank for localtime
 # timezone =
 

alembic/templates/generic/alembic.ini.mako

@@ -16,9 +16,9 @@ prepend_sys_path = .
 
 # timezone to use when rendering the date within the migration file
 # as well as the filename.
-# If specified, requires the python-dateutil library that can be
-# installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to dateutil.tz.gettz()
+# If specified, requires the python>=3.9 or backports.zoneinfo library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
 # leave blank for localtime
 # timezone =
 

alembic/templates/multidb/alembic.ini.mako

@@ -16,9 +16,9 @@ prepend_sys_path = .
 
 # timezone to use when rendering the date within the migration file
 # as well as the filename.
-# If specified, requires the python-dateutil library that can be
-# installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to dateutil.tz.gettz()
+# If specified, requires the python>=3.9 or backports.zoneinfo library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
 # leave blank for localtime
 # timezone =
 

alembic/testing/requirements.py

@@ -95,6 +95,18 @@ class SuiteRequirements(Requirements):
             "SQLAlchemy 2.x test",
         )
 
+    @property
+    def asyncio(self):
+        def go(config):
+            try:
+                import greenlet  # noqa: F401
+            except ImportError:
+                return False
+            else:
+                return True
+
+        return self.sqlalchemy_14 + exclusions.only_if(go)
+
     @property
     def comments(self):
         return exclusions.only_if(
@@ -196,7 +208,3 @@ class SuiteRequirements(Requirements):
         return exclusions.only_if(
             exclusions.BooleanPredicate(sqla_compat.has_identity)
         )
-
-    @property
-    def supports_identity_on_null(self):
-        return exclusions.closed()

alembic/testing/schemacompare.py

@@ -1,6 +1,7 @@
 from itertools import zip_longest
 
 from sqlalchemy import schema
+from sqlalchemy.sql.elements import ClauseList
 
 
 class CompareTable:
@@ -60,6 +61,14 @@ class CompareIndex:
     def __ne__(self, other):
         return not self.__eq__(other)
 
+    def __repr__(self):
+        expr = ClauseList(*self.index.expressions)
+        try:
+            expr_str = expr.compile().string
+        except Exception:
+            expr_str = str(expr)
+        return f"<CompareIndex {self.index.name}({expr_str})>"
+
 
 class CompareCheckConstraint:
     def __init__(self, constraint):

alembic/testing/suite/test_autogen_identity.py

@@ -4,6 +4,7 @@ from sqlalchemy import Integer
 from sqlalchemy import MetaData
 from sqlalchemy import Table
 
+from alembic.util import sqla_compat
 from ._autogen_fixtures import AutogenFixtureTest
 from ... import testing
 from ...testing import config
@@ -78,16 +79,33 @@ class AutogenerateIdentityTest(AutogenFixtureTest, TestBase):
         m2 = MetaData()
 
         for m in (m1, m2):
-            Table(
-                "user",
-                m,
-                Column("id", Integer, sa.Identity(start=2)),
-            )
+            id_ = sa.Identity(start=2)
+            Table("user", m, Column("id", Integer, id_))
 
         diffs = self._fixture(m1, m2)
 
         eq_(diffs, [])
 
+    def test_dialect_kwargs_changes(self):
+        m1 = MetaData()
+        m2 = MetaData()
+
+        if sqla_compat.identity_has_dialect_kwargs:
+            args = {"oracle_on_null": True, "oracle_order": True}
+        else:
+            args = {"on_null": True, "order": True}
+
+        Table("user", m1, Column("id", Integer, sa.Identity(start=2)))
+        id_ = sa.Identity(start=2, **args)
+        Table("user", m2, Column("id", Integer, id_))
+
+        diffs = self._fixture(m1, m2)
+        if config.db.name == "oracle":
+            is_true(len(diffs), 1)
+            eq_(diffs[0][0][0], "modify_default")
+        else:
+            eq_(diffs, [])
+
     @testing.combinations(
         (None, dict(start=2)),
         (dict(start=2), None),
@@ -206,36 +224,3 @@ class AutogenerateIdentityTest(AutogenFixtureTest, TestBase):
         removed = diffs[5]
 
         is_true(isinstance(removed, sa.Identity))
-
-    def test_identity_on_null(self):
-        m1 = MetaData()
-        m2 = MetaData()
-
-        Table(
-            "user",
-            m1,
-            Column("id", Integer, sa.Identity(start=2, on_null=True)),
-            Column("other", sa.Text),
-        )
-
-        Table(
-            "user",
-            m2,
-            Column("id", Integer, sa.Identity(start=2, on_null=False)),
-            Column("other", sa.Text),
-        )
-
-        diffs = self._fixture(m1, m2)
-        if not config.requirements.supports_identity_on_null.enabled:
-            eq_(diffs, [])
-        else:
-            eq_(len(diffs[0]), 1)
-            diffs = diffs[0][0]
-            eq_(diffs[0], "modify_default")
-            eq_(diffs[2], "user")
-            eq_(diffs[3], "id")
-            old = diffs[5]
-            new = diffs[6]
-
-            is_true(isinstance(old, sa.Identity))
-            is_true(isinstance(new, sa.Identity))

alembic/util/compat.py

@@ -16,7 +16,6 @@ is_posix = os.name == "posix"
 py311 = sys.version_info >= (3, 11)
 py310 = sys.version_info >= (3, 10)
 py39 = sys.version_info >= (3, 9)
-py38 = sys.version_info >= (3, 8)
 
 
 # produce a wrapper that allows encoded text to stream

alembic/util/sqla_compat.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import contextlib
 import re
 from typing import Any
+from typing import Dict
 from typing import Iterable
 from typing import Iterator
 from typing import Mapping
@@ -22,6 +23,7 @@ from sqlalchemy.schema import CheckConstraint
 from sqlalchemy.schema import Column
 from sqlalchemy.schema import ForeignKeyConstraint
 from sqlalchemy.sql import visitors
+from sqlalchemy.sql.base import DialectKWArgs
 from sqlalchemy.sql.elements import BindParameter
 from sqlalchemy.sql.elements import ColumnClause
 from sqlalchemy.sql.elements import quoted_name
@@ -80,9 +82,10 @@ class _Unsupported:
 try:
     from sqlalchemy import Computed
 except ImportError:
+    if not TYPE_CHECKING:
 
-    class Computed(_Unsupported):  # type: ignore
-        pass
+        class Computed(_Unsupported):
+            pass
 
     has_computed = False
     has_computed_reflection = False
@@ -93,26 +96,54 @@ else:
 try:
     from sqlalchemy import Identity
 except ImportError:
+    if not TYPE_CHECKING:
 
-    class Identity(_Unsupported):  # type: ignore
-        pass
+        class Identity(_Unsupported):
+            pass
 
     has_identity = False
 else:
-    # attributes common to Identity and Sequence
-    _identity_options_attrs = (
-        "start",
-        "increment",
-        "minvalue",
-        "maxvalue",
-        "nominvalue",
-        "nomaxvalue",
-        "cycle",
-        "cache",
-        "order",
-    )
-    # attributes of Identity
-    _identity_attrs = _identity_options_attrs + ("on_null",)
+    identity_has_dialect_kwargs = issubclass(Identity, DialectKWArgs)
+
+    def _get_identity_options_dict(
+        identity: Union[Identity, schema.Sequence, None],
+        dialect_kwargs: bool = False,
+    ) -> Dict[str, Any]:
+        if identity is None:
+            return {}
+        elif identity_has_dialect_kwargs:
+            as_dict = identity._as_dict()  # type: ignore
+            if dialect_kwargs:
+                assert isinstance(identity, DialectKWArgs)
+                as_dict.update(identity.dialect_kwargs)
+        else:
+            as_dict = {}
+            if isinstance(identity, Identity):
+                # always=None means something different than always=False
+                as_dict["always"] = identity.always
+                if identity.on_null is not None:
+                    as_dict["on_null"] = identity.on_null
+            # attributes common to Identity and Sequence
+            attrs = (
+                "start",
+                "increment",
+                "minvalue",
+                "maxvalue",
+                "nominvalue",
+                "nomaxvalue",
+                "cycle",
+                "cache",
+                "order",
+            )
+            as_dict.update(
+                {
+                    key: getattr(identity, key, None)
+                    for key in attrs
+                    if getattr(identity, key, None) is not None
+                }
+            )
+        return as_dict
+
     has_identity = True
 
 if sqla_2:
@@ -493,14 +524,6 @@ def _render_literal_bindparam(
     return compiler.render_literal_bindparam(element, **kw)
 
 
-def _get_index_expressions(idx):
-    return list(idx.expressions)
-
-
-def _get_index_column_names(idx):
-    return [getattr(exp, "name", None) for exp in _get_index_expressions(idx)]
-
-
 def _column_kwargs(col: Column) -> Mapping:
     if sqla_13:
         return col.kwargs
@@ -599,10 +622,15 @@ else:
 
 
 def is_expression_index(index: Index) -> bool:
-    expr: Any
     for expr in index.expressions:
-        while isinstance(expr, UnaryExpression):
-            expr = expr.element
-        if not isinstance(expr, ColumnClause) or expr.is_literal:
+        if is_expression(expr):
             return True
     return False
+
+
+def is_expression(expr: Any) -> bool:
+    while isinstance(expr, UnaryExpression):
+        expr = expr.element
+    if not isinstance(expr, ColumnClause) or expr.is_literal:
+        return True
+    return False

{alembic-1.12.0.dist-info → alembic-1.13.0.dist-info}/METADATA

@@ -1,13 +1,14 @@
 Metadata-Version: 2.1
 Name: alembic
-Version: 1.12.0
+Version: 1.13.0
 Summary: A database migration tool for SQLAlchemy.
 Home-page: https://alembic.sqlalchemy.org
 Author: Mike Bayer
 Author-email: mike_mp@zzzcomputing.com
 License: MIT
-Project-URL: Source, https://github.com/sqlalchemy/alembic/
 Project-URL: Documentation, https://alembic.sqlalchemy.org/en/latest/
+Project-URL: Changelog, https://alembic.sqlalchemy.org/en/latest/changelog.html
+Project-URL: Source, https://github.com/sqlalchemy/alembic/
 Project-URL: Issue Tracker, https://github.com/sqlalchemy/alembic/issues/
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -16,14 +17,15 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Database :: Front-Ends
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: SQLAlchemy >=1.3.0
@@ -32,7 +34,7 @@ Requires-Dist: typing-extensions >=4
 Requires-Dist: importlib-metadata ; python_version < "3.9"
 Requires-Dist: importlib-resources ; python_version < "3.9"
 Provides-Extra: tz
-Requires-Dist: python-dateutil ; extra == 'tz'
+Requires-Dist: backports.zoneinfo ; (python_version < "3.9") and extra == 'tz'
 
 Alembic is a database migrations tool written by the author
 of `SQLAlchemy <http://www.sqlalchemy.org>`_.  A migrations tool
@@ -101,7 +103,7 @@ The goals of Alembic are:
 * Provide a library of ALTER constructs that can be used by any SQLAlchemy
   application. The DDL constructs build upon SQLAlchemy's own DDLElement base
   and can be used standalone by any application or script.
-* At long last, bring SQLite and its inablity to ALTER things into the fold,
+* At long last, bring SQLite and its inability to ALTER things into the fold,
   but in such a way that SQLite's very special workflow needs are accommodated
   in an explicit way that makes the most of a bad situation, through the
   concept of a "batch" migration, where multiple changes to a table can