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

alembic/script/revision.py

@@ -14,6 +14,7 @@ from typing import Iterator
 from typing import List
 from typing import Optional
 from typing import overload
+from typing import Protocol
 from typing import Sequence
 from typing import Set
 from typing import Tuple
@@ -47,6 +48,18 @@ _relative_destination = re.compile(r"(?:(.+?)@)?(\w+)?((?:\+|-)\d+)")
 _revision_illegal_chars = ["@", "-", "+"]
 
 
+class _CollectRevisionsProtocol(Protocol):
+    def __call__(
+        self,
+        upper: _RevisionIdentifierType,
+        lower: _RevisionIdentifierType,
+        inclusive: bool,
+        implicit_base: bool,
+        assert_relative_length: bool,
+    ) -> Tuple[Set[Revision], Tuple[Optional[_RevisionOrBase], ...]]:
+        ...
+
+
 class RevisionError(Exception):
     pass
 
@@ -396,7 +409,7 @@ class RevisionMap:
                 for rev in self._get_ancestor_nodes(
                     [revision],
                     include_dependencies=False,
-                    map_=cast(_RevisionMapType, map_),
+                    map_=map_,
                 ):
                     if rev is revision:
                         continue
@@ -791,7 +804,7 @@ class RevisionMap:
         The iterator yields :class:`.Revision` objects.
 
         """
-        fn: Callable
+        fn: _CollectRevisionsProtocol
         if select_for_downgrade:
             fn = self._collect_downgrade_revisions
         else:
@@ -818,7 +831,7 @@ class RevisionMap:
     ) -> Iterator[Any]:
         if omit_immediate_dependencies:
 
-            def fn(rev):
+            def fn(rev: Revision) -> Iterable[str]:
                 if rev not in targets:
                     return rev._all_nextrev
                 else:
@@ -826,12 +839,12 @@ class RevisionMap:
 
         elif include_dependencies:
 
-            def fn(rev):
+            def fn(rev: Revision) -> Iterable[str]:
                 return rev._all_nextrev
 
         else:
 
-            def fn(rev):
+            def fn(rev: Revision) -> Iterable[str]:
                 return rev.nextrev
 
         return self._iterate_related_revisions(
@@ -847,12 +860,12 @@ class RevisionMap:
     ) -> Iterator[Revision]:
         if include_dependencies:
 
-            def fn(rev):
+            def fn(rev: Revision) -> Iterable[str]:
                 return rev._normalized_down_revisions
 
         else:
 
-            def fn(rev):
+            def fn(rev: Revision) -> Iterable[str]:
                 return rev._versioned_down_revisions
 
         return self._iterate_related_revisions(
@@ -861,7 +874,7 @@ class RevisionMap:
 
     def _iterate_related_revisions(
         self,
-        fn: Callable,
+        fn: Callable[[Revision], Iterable[str]],
         targets: Collection[Optional[_RevisionOrBase]],
         map_: Optional[_RevisionMapType],
         check: bool = False,
@@ -923,7 +936,7 @@ class RevisionMap:
 
         id_to_rev = self._revision_map
 
-        def get_ancestors(rev_id):
+        def get_ancestors(rev_id: str) -> Set[str]:
             return {
                 r.revision
                 for r in self._get_ancestor_nodes([id_to_rev[rev_id]])
@@ -1041,7 +1054,7 @@ class RevisionMap:
         children: Sequence[Optional[_RevisionOrBase]]
         for _ in range(abs(steps)):
             if steps > 0:
-                assert initial != "base"
+                assert initial != "base"  # type: ignore[comparison-overlap]
                 # Walk up
                 walk_up = [
                     is_revision(rev)
@@ -1055,7 +1068,7 @@ class RevisionMap:
                     children = walk_up
             else:
                 # Walk down
-                if initial == "base":
+                if initial == "base":  # type: ignore[comparison-overlap]
                     children = ()
                 else:
                     children = self.get_revisions(
@@ -1189,7 +1202,7 @@ class RevisionMap:
         # No relative destination given, revision specified is absolute.
         branch_label, _, symbol = target.rpartition("@")
         if not branch_label:
-            branch_label = None  # type:ignore[assignment]
+            branch_label = None
         return branch_label, self.get_revision(symbol)
 
     def _parse_upgrade_target(
@@ -1301,11 +1314,11 @@ class RevisionMap:
     def _collect_downgrade_revisions(
         self,
         upper: _RevisionIdentifierType,
-        target: _RevisionIdentifierType,
+        lower: _RevisionIdentifierType,
         inclusive: bool,
         implicit_base: bool,
         assert_relative_length: bool,
-    ) -> Any:
+    ) -> Tuple[Set[Revision], Tuple[Optional[_RevisionOrBase], ...]]:
         """
         Compute the set of current revisions specified by :upper, and the
         downgrade target specified by :target. Return all dependents of target
@@ -1316,7 +1329,7 @@ class RevisionMap:
 
         branch_label, target_revision = self._parse_downgrade_target(
             current_revisions=upper,
-            target=target,
+            target=lower,
             assert_relative_length=assert_relative_length,
         )
         if target_revision == "base":
@@ -1408,7 +1421,7 @@ class RevisionMap:
         inclusive: bool,
         implicit_base: bool,
         assert_relative_length: bool,
-    ) -> Tuple[Set[Revision], Tuple[Optional[_RevisionOrBase]]]:
+    ) -> Tuple[Set[Revision], Tuple[Revision, ...]]:
         """
         Compute the set of required revisions specified by :upper, and the
         current set of active revisions specified by :lower. Find the
@@ -1500,7 +1513,7 @@ class RevisionMap:
             )
             needs.intersection_update(lower_descendents)
 
-        return needs, tuple(targets)  # type:ignore[return-value]
+        return needs, tuple(targets)
 
     def _get_all_current(
         self, id_: Tuple[str, ...]

alembic/script/write_hooks.py

@@ -1,3 +1,6 @@
+# mypy: allow-untyped-defs, allow-incomplete-defs, allow-untyped-calls
+# mypy: no-warn-return-any, allow-any-generics
+
 from __future__ import annotations
 
 import shlex

alembic/util/__init__.py

@@ -1,34 +1,34 @@
-from .editor import open_in_editor
-from .exc import AutogenerateDiffsDetected
-from .exc import CommandError
-from .langhelpers import _with_legacy_names
-from .langhelpers import asbool
-from .langhelpers import dedupe_tuple
-from .langhelpers import Dispatcher
-from .langhelpers import EMPTY_DICT
-from .langhelpers import immutabledict
-from .langhelpers import memoized_property
-from .langhelpers import ModuleClsProxy
-from .langhelpers import not_none
-from .langhelpers import rev_id
-from .langhelpers import to_list
-from .langhelpers import to_tuple
-from .langhelpers import unique_list
-from .messaging import err
-from .messaging import format_as_comma
-from .messaging import msg
-from .messaging import obfuscate_url_pw
-from .messaging import status
-from .messaging import warn
-from .messaging import write_outstream
-from .pyfiles import coerce_resource_to_filename
-from .pyfiles import load_python_file
-from .pyfiles import pyc_file_from_path
-from .pyfiles import template_to_file
-from .sqla_compat import has_computed
-from .sqla_compat import sqla_13
-from .sqla_compat import sqla_14
-from .sqla_compat import sqla_2
+from .editor import open_in_editor as open_in_editor
+from .exc import AutogenerateDiffsDetected as AutogenerateDiffsDetected
+from .exc import CommandError as CommandError
+from .langhelpers import _with_legacy_names as _with_legacy_names
+from .langhelpers import asbool as asbool
+from .langhelpers import dedupe_tuple as dedupe_tuple
+from .langhelpers import Dispatcher as Dispatcher
+from .langhelpers import EMPTY_DICT as EMPTY_DICT
+from .langhelpers import immutabledict as immutabledict
+from .langhelpers import memoized_property as memoized_property
+from .langhelpers import ModuleClsProxy as ModuleClsProxy
+from .langhelpers import not_none as not_none
+from .langhelpers import rev_id as rev_id
+from .langhelpers import to_list as to_list
+from .langhelpers import to_tuple as to_tuple
+from .langhelpers import unique_list as unique_list
+from .messaging import err as err
+from .messaging import format_as_comma as format_as_comma
+from .messaging import msg as msg
+from .messaging import obfuscate_url_pw as obfuscate_url_pw
+from .messaging import status as status
+from .messaging import warn as warn
+from .messaging import write_outstream as write_outstream
+from .pyfiles import coerce_resource_to_filename as coerce_resource_to_filename
+from .pyfiles import load_python_file as load_python_file
+from .pyfiles import pyc_file_from_path as pyc_file_from_path
+from .pyfiles import template_to_file as template_to_file
+from .sqla_compat import has_computed as has_computed
+from .sqla_compat import sqla_13 as sqla_13
+from .sqla_compat import sqla_14 as sqla_14
+from .sqla_compat import sqla_2 as sqla_2
 
 
 if not sqla_13:

alembic/util/compat.py

@@ -1,3 +1,5 @@
+# mypy: no-warn-unused-ignores
+
 from __future__ import annotations
 
 from configparser import ConfigParser
@@ -5,11 +7,20 @@ import io
 import os
 import sys
 import typing
+from typing import Any
+from typing import List
+from typing import Optional
 from typing import Sequence
 from typing import Union
 
-from sqlalchemy.util import inspect_getfullargspec  # noqa
-from sqlalchemy.util.compat import inspect_formatargspec  # noqa
+if True:
+    # zimports hack for too-long names
+    from sqlalchemy.util import (  # noqa: F401
+        inspect_getfullargspec as inspect_getfullargspec,
+    )
+    from sqlalchemy.util.compat import (  # noqa: F401
+        inspect_formatargspec as inspect_formatargspec,
+    )
 
 is_posix = os.name == "posix"
 
@@ -27,9 +38,13 @@ class EncodedIO(io.TextIOWrapper):
 
 
 if py39:
-    from importlib import resources as importlib_resources
-    from importlib import metadata as importlib_metadata
-    from importlib.metadata import EntryPoint
+    from importlib import resources as _resources
+
+    importlib_resources = _resources
+    from importlib import metadata as _metadata
+
+    importlib_metadata = _metadata
+    from importlib.metadata import EntryPoint as EntryPoint
 else:
     import importlib_resources  # type:ignore # noqa
     import importlib_metadata  # type:ignore # noqa
@@ -39,12 +54,14 @@ else:
 def importlib_metadata_get(group: str) -> Sequence[EntryPoint]:
     ep = importlib_metadata.entry_points()
     if hasattr(ep, "select"):
-        return ep.select(group=group)  # type: ignore
+        return ep.select(group=group)
     else:
         return ep.get(group, ())  # type: ignore
 
 
-def formatannotation_fwdref(annotation, base_module=None):
+def formatannotation_fwdref(
+    annotation: Any, base_module: Optional[Any] = None
+) -> str:
     """vendored from python 3.7"""
     # copied over _formatannotation from sqlalchemy 2.0
 
@@ -65,7 +82,7 @@ def formatannotation_fwdref(annotation, base_module=None):
 def read_config_parser(
     file_config: ConfigParser,
     file_argument: Sequence[Union[str, os.PathLike[str]]],
-) -> list[str]:
+) -> List[str]:
     if py310:
         return file_config.read(file_argument, encoding="locale")
     else:

alembic/util/langhelpers.py

@@ -5,33 +5,46 @@ from collections.abc import Iterable
 import textwrap
 from typing import Any
 from typing import Callable
+from typing import cast
 from typing import Dict
 from typing import List
 from typing import Mapping
+from typing import MutableMapping
+from typing import NoReturn
 from typing import Optional
 from typing import overload
 from typing import Sequence
+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
 import uuid
 import warnings
 
-from sqlalchemy.util import asbool  # noqa
-from sqlalchemy.util import immutabledict  # noqa
-from sqlalchemy.util import memoized_property  # noqa
-from sqlalchemy.util import to_list  # noqa
-from sqlalchemy.util import unique_list  # noqa
+from sqlalchemy.util import asbool as asbool  # noqa: F401
+from sqlalchemy.util import immutabledict as immutabledict  # noqa: F401
+from sqlalchemy.util import to_list as to_list  # noqa: F401
+from sqlalchemy.util import unique_list as unique_list
 
 from .compat import inspect_getfullargspec
 
+if True:
+    # zimports workaround :(
+    from sqlalchemy.util import (  # noqa: F401
+        memoized_property as memoized_property,
+    )
+
 
 EMPTY_DICT: Mapping[Any, Any] = immutabledict()
-_T = TypeVar("_T")
+_T = TypeVar("_T", bound=Any)
+
+_C = TypeVar("_C", bound=Callable[..., Any])
 
 
 class _ModuleClsMeta(type):
-    def __setattr__(cls, key: str, value: Callable) -> None:
+    def __setattr__(cls, key: str, value: Callable[..., Any]) -> None:
         super().__setattr__(key, value)
         cls._update_module_proxies(key)  # type: ignore
 
@@ -45,9 +58,13 @@ class ModuleClsProxy(metaclass=_ModuleClsMeta):
 
     """
 
-    _setups: Dict[type, Tuple[set, list]] = collections.defaultdict(
-        lambda: (set(), [])
-    )
+    _setups: Dict[
+        Type[Any],
+        Tuple[
+            Set[str],
+            List[Tuple[MutableMapping[str, Any], MutableMapping[str, Any]]],
+        ],
+    ] = collections.defaultdict(lambda: (set(), []))
 
     @classmethod
     def _update_module_proxies(cls, name: str) -> None:
@@ -70,18 +87,33 @@ class ModuleClsProxy(metaclass=_ModuleClsMeta):
                 del globals_[attr_name]
 
     @classmethod
-    def create_module_class_proxy(cls, globals_, locals_):
+    def create_module_class_proxy(
+        cls,
+        globals_: MutableMapping[str, Any],
+        locals_: MutableMapping[str, Any],
+    ) -> None:
         attr_names, modules = cls._setups[cls]
         modules.append((globals_, locals_))
         cls._setup_proxy(globals_, locals_, attr_names)
 
     @classmethod
-    def _setup_proxy(cls, globals_, locals_, attr_names):
+    def _setup_proxy(
+        cls,
+        globals_: MutableMapping[str, Any],
+        locals_: MutableMapping[str, Any],
+        attr_names: Set[str],
+    ) -> None:
         for methname in dir(cls):
             cls._add_proxied_attribute(methname, globals_, locals_, attr_names)
 
     @classmethod
-    def _add_proxied_attribute(cls, methname, globals_, locals_, attr_names):
+    def _add_proxied_attribute(
+        cls,
+        methname: str,
+        globals_: MutableMapping[str, Any],
+        locals_: MutableMapping[str, Any],
+        attr_names: Set[str],
+    ) -> None:
         if not methname.startswith("_"):
             meth = getattr(cls, methname)
             if callable(meth):
@@ -92,10 +124,15 @@ class ModuleClsProxy(metaclass=_ModuleClsMeta):
                 attr_names.add(methname)
 
     @classmethod
-    def _create_method_proxy(cls, name, globals_, locals_):
+    def _create_method_proxy(
+        cls,
+        name: str,
+        globals_: MutableMapping[str, Any],
+        locals_: MutableMapping[str, Any],
+    ) -> Callable[..., Any]:
         fn = getattr(cls, name)
 
-        def _name_error(name, from_):
+        def _name_error(name: str, from_: Exception) -> NoReturn:
             raise NameError(
                 "Can't invoke function '%s', as the proxy object has "
                 "not yet been "
@@ -119,7 +156,9 @@ class ModuleClsProxy(metaclass=_ModuleClsMeta):
                 translations,
             )
 
-            def translate(fn_name, spec, translations, args, kw):
+            def translate(
+                fn_name: str, spec: Any, translations: Any, args: Any, kw: Any
+            ) -> Any:
                 return_kw = {}
                 return_args = []
 
@@ -176,15 +215,15 @@ class ModuleClsProxy(metaclass=_ModuleClsMeta):
                 "doc": fn.__doc__,
             }
         )
-        lcl = {}
+        lcl: MutableMapping[str, Any] = {}
 
-        exec(func_text, globals_, lcl)
-        return lcl[name]
+        exec(func_text, cast("Dict[str, Any]", globals_), lcl)
+        return cast("Callable[..., Any]", lcl[name])
 
 
-def _with_legacy_names(translations):
-    def decorate(fn):
-        fn._legacy_translations = translations
+def _with_legacy_names(translations: Any) -> Any:
+    def decorate(fn: _C) -> _C:
+        fn._legacy_translations = translations  # type: ignore[attr-defined]
         return fn
 
     return decorate
@@ -195,21 +234,25 @@ def rev_id() -> str:
 
 
 @overload
-def to_tuple(x: Any, default: tuple) -> tuple:
+def to_tuple(x: Any, default: Tuple[Any, ...]) -> Tuple[Any, ...]:
     ...
 
 
 @overload
-def to_tuple(x: None, default: Optional[_T] = None) -> _T:
+def to_tuple(x: None, default: Optional[_T] = ...) -> _T:
     ...
 
 
 @overload
-def to_tuple(x: Any, default: Optional[tuple] = None) -> tuple:
+def to_tuple(
+    x: Any, default: Optional[Tuple[Any, ...]] = None
+) -> Tuple[Any, ...]:
     ...
 
 
-def to_tuple(x, default=None):
+def to_tuple(
+    x: Any, default: Optional[Tuple[Any, ...]] = None
+) -> Optional[Tuple[Any, ...]]:
     if x is None:
         return default
     elif isinstance(x, str):
@@ -226,13 +269,13 @@ def dedupe_tuple(tup: Tuple[str, ...]) -> Tuple[str, ...]:
 
 class Dispatcher:
     def __init__(self, uselist: bool = False) -> None:
-        self._registry: Dict[tuple, Any] = {}
+        self._registry: Dict[Tuple[Any, ...], Any] = {}
         self.uselist = uselist
 
     def dispatch_for(
         self, target: Any, qualifier: str = "default"
-    ) -> Callable:
-        def decorate(fn):
+    ) -> Callable[[_C], _C]:
+        def decorate(fn: _C) -> _C:
             if self.uselist:
                 self._registry.setdefault((target, qualifier), []).append(fn)
             else:
@@ -244,7 +287,7 @@ class Dispatcher:
 
     def dispatch(self, obj: Any, qualifier: str = "default") -> Any:
         if isinstance(obj, str):
-            targets: Sequence = [obj]
+            targets: Sequence[Any] = [obj]
         elif isinstance(obj, type):
             targets = obj.__mro__
         else:
@@ -259,11 +302,13 @@ class Dispatcher:
             raise ValueError("no dispatch function for object: %s" % obj)
 
     def _fn_or_list(
-        self, fn_or_list: Union[List[Callable], Callable]
-    ) -> Callable:
+        self, fn_or_list: Union[List[Callable[..., Any]], Callable[..., Any]]
+    ) -> Callable[..., Any]:
         if self.uselist:
 
-            def go(*arg, **kw):
+            def go(*arg: Any, **kw: Any) -> None:
+                if TYPE_CHECKING:
+                    assert isinstance(fn_or_list, Sequence)
                 for fn in fn_or_list:
                     fn(*arg, **kw)
 

alembic/util/messaging.py

@@ -5,6 +5,7 @@ from contextlib import contextmanager
 import logging
 import sys
 import textwrap
+from typing import Iterator
 from typing import Optional
 from typing import TextIO
 from typing import Union
@@ -53,7 +54,9 @@ def write_outstream(
 
 
 @contextmanager
-def status(status_msg: str, newline: bool = False, quiet: bool = False):
+def status(
+    status_msg: str, newline: bool = False, quiet: bool = False
+) -> Iterator[None]:
     msg(status_msg + " ...", newline, flush=True, quiet=quiet)
     try:
         yield
@@ -66,7 +69,7 @@ def status(status_msg: str, newline: bool = False, quiet: bool = False):
             write_outstream(sys.stdout, "  done\n")
 
 
-def err(message: str, quiet: bool = False):
+def err(message: str, quiet: bool = False) -> None:
     log.error(message)
     msg(f"FAILED: {message}", quiet=quiet)
     sys.exit(-1)
@@ -74,7 +77,7 @@ def err(message: str, quiet: bool = False):
 
 def obfuscate_url_pw(input_url: str) -> str:
     u = url.make_url(input_url)
-    return sqla_compat.url_render_as_string(u, hide_password=True)
+    return sqla_compat.url_render_as_string(u, hide_password=True)  # type: ignore  # noqa: E501
 
 
 def warn(msg: str, stacklevel: int = 2) -> None:

alembic/util/pyfiles.py

@@ -8,6 +8,8 @@ import importlib.util
 import os
 import re
 import tempfile
+from types import ModuleType
+from typing import Any
 from typing import Optional
 
 from mako import exceptions
@@ -18,7 +20,7 @@ from .exc import CommandError
 
 
 def template_to_file(
-    template_file: str, dest: str, output_encoding: str, **kw
+    template_file: str, dest: str, output_encoding: str, **kw: Any
 ) -> None:
     template = Template(filename=template_file)
     try:
@@ -82,7 +84,7 @@ def pyc_file_from_path(path: str) -> Optional[str]:
         return None
 
 
-def load_python_file(dir_: str, filename: str):
+def load_python_file(dir_: str, filename: str) -> ModuleType:
     """Load a file from the given path as a Python module."""
 
     module_id = re.sub(r"\W", "_", filename)
@@ -99,10 +101,12 @@ def load_python_file(dir_: str, filename: str):
                 module = load_module_py(module_id, pyc_path)
     elif ext in (".pyc", ".pyo"):
         module = load_module_py(module_id, path)
+    else:
+        assert False
     return module
 
 
-def load_module_py(module_id: str, path: str):
+def load_module_py(module_id: str, path: str) -> ModuleType:
     spec = importlib.util.spec_from_file_location(module_id, path)
     assert spec
     module = importlib.util.module_from_spec(spec)