# testing/fixtures/mypy.py
# Copyright (C) 2005-2025 the SQLAlchemy authors and contributors
# <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: https://www.opensource.org/licenses/mit-license.php
# mypy: ignore-errors
from __future__ import annotations
import inspect
import os
from pathlib import Path
import re
import shutil
import sys
import tempfile
from .base import TestBase
from .. import config
from ..assertions import eq_
from ... import util
@config.add_to_marker.mypy
class MypyTest(TestBase):
__requires__ = ("no_sqlalchemy2_stubs",)
@config.fixture(scope="function")
def per_func_cachedir(self):
yield from self._cachedir()
@config.fixture(scope="class")
def cachedir(self):
yield from self._cachedir()
def _cachedir(self):
# as of mypy 0.971 i think we need to keep mypy_path empty
mypy_path = ""
with tempfile.TemporaryDirectory() as cachedir:
with open(
Path(cachedir) / "sqla_mypy_config.cfg", "w"
) as config_file:
config_file.write(
f"""
[mypy]\n
plugins = sqlalchemy.ext.mypy.plugin\n
show_error_codes = True\n
{mypy_path}
disable_error_code = no-untyped-call
[mypy-sqlalchemy.*]
ignore_errors = True
"""
)
with open(
Path(cachedir) / "plain_mypy_config.cfg", "w"
) as config_file:
config_file.write(
f"""
[mypy]\n
show_error_codes = True\n
{mypy_path}
disable_error_code = var-annotated,no-untyped-call
[mypy-sqlalchemy.*]
ignore_errors = True
"""
)
yield cachedir
@config.fixture()
def mypy_runner(self, cachedir):
from mypy import api
def run(path, use_plugin=False, use_cachedir=None):
if use_cachedir is None:
use_cachedir = cachedir
args = [
"--strict",
"--raise-exceptions",
"--cache-dir",
use_cachedir,
"--config-file",
os.path.join(
use_cachedir,
(
"sqla_mypy_config.cfg"
if use_plugin
else "plain_mypy_config.cfg"
),
),
]
# mypy as of 0.990 is more aggressively blocking messaging
# for paths that are in sys.path, and as pytest puts currdir,
# test/ etc in sys.path, just copy the source file to the
# tempdir we are working in so that we don't have to try to
# manipulate sys.path and/or guess what mypy is doing
filename = os.path.basename(path)
test_program = os.path.join(use_cachedir, filename)
if path != test_program:
shutil.copyfile(path, test_program)
args.append(test_program)
# I set this locally but for the suite here needs to be
# disabled
os.environ.pop("MYPY_FORCE_COLOR", None)
stdout, stderr, exitcode = api.run(args)
return stdout, stderr, exitcode
return run
@config.fixture
def mypy_typecheck_file(self, mypy_runner):
def run(path, use_plugin=False):
expected_messages = self._collect_messages(path)
stdout, stderr, exitcode = mypy_runner(path, use_plugin=use_plugin)
self._check_output(
path, expected_messages, stdout, stderr, exitcode
)
return run
@staticmethod
def file_combinations(dirname):
if os.path.isabs(dirname):
path = dirname
else:
caller_path = inspect.stack()[1].filename
path = os.path.join(os.path.dirname(caller_path), dirname)
files = list(Path(path).glob("**/*.py"))
for extra_dir in config.options.mypy_extra_test_paths:
if extra_dir and os.path.isdir(extra_dir):
files.extend((Path(extra_dir) / dirname).glob("**/*.py"))
return files
def _collect_messages(self, path):
from sqlalchemy.ext.mypy.util import mypy_14
expected_messages = []
expected_re = re.compile(r"\s*# EXPECTED(_MYPY)?(_RE)?(_TYPE)?: (.+)")
py_ver_re = re.compile(r"^#\s*PYTHON_VERSION\s?>=\s?(\d+\.\d+)")
with open(path) as file_:
current_assert_messages = []
for num, line in enumerate(file_, 1):
m = py_ver_re.match(line)
if m:
major, _, minor = m.group(1).partition(".")
if sys.version_info < (int(major), int(minor)):
config.skip_test(
"Requires python >= %s" % (m.group(1))
)
continue
m = expected_re.match(line)
if m:
is_mypy = bool(m.group(1))
is_re = bool(m.group(2))
is_type = bool(m.group(3))
expected_msg = re.sub(r"# noqa[:]? ?.*", "", m.group(4))
if is_type:
if not is_re:
# the goal here is that we can cut-and-paste
# from vscode -> pylance into the
# EXPECTED_TYPE: line, then the test suite will
# validate that line against what mypy produces
expected_msg = re.sub(
r"([\[\]])",
lambda m: rf"\{m.group(0)}",
expected_msg,
)
# note making sure preceding text matches
# with a dot, so that an expect for "Select"
# does not match "TypedSelect"
expected_msg = re.sub(
r"([\w_]+)",
lambda m: rf"(?:.*\.)?{m.group(1)}\*?",
expected_msg,
)
expected_msg = re.sub(
"List", "builtins.list", expected_msg
)
expected_msg = re.sub(
r"\b(int|str|float|bool)\b",
lambda m: rf"builtins.{m.group(0)}\*?",
expected_msg,
)
# expected_msg = re.sub(
# r"(Sequence|Tuple|List|Union)",
# lambda m: fr"typing.{m.group(0)}\*?",
# expected_msg,
# )
is_mypy = is_re = True
expected_msg = f'Revealed type is "{expected_msg}"'
if mypy_14 and util.py39:
# use_lowercase_names, py39 and above
# https://github.com/python/mypy/blob/304997bfb85200fb521ac727ee0ce3e6085e5278/mypy/options.py#L363 # noqa: E501
# skip first character which could be capitalized
# "List item x not found" type of message
expected_msg = expected_msg[0] + re.sub(
(
r"\b(List|Tuple|Dict|Set)\b"
if is_type
else r"\b(List|Tuple|Dict|Set|Type)\b"
),
lambda m: m.group(1).lower(),
expected_msg[1:],
)
if mypy_14 and util.py310:
# use_or_syntax, py310 and above
# https://github.com/python/mypy/blob/304997bfb85200fb521ac727ee0ce3e6085e5278/mypy/options.py#L368 # noqa: E501
expected_msg = re.sub(
r"Optional\[(.*?)\]",
lambda m: f"{m.group(1)} | None",
expected_msg,
)
current_assert_messages.append(
(is_mypy, is_re, expected_msg.strip())
)
elif current_assert_messages:
expected_messages.extend(
(num, is_mypy, is_re, expected_msg)
for (
is_mypy,
is_re,
expected_msg,
) in current_assert_messages
)
current_assert_messages[:] = []
return expected_messages
def _check_output(self, path, expected_messages, stdout, stderr, exitcode):
not_located = []
filename = os.path.basename(path)
if expected_messages:
# mypy 0.990 changed how return codes work, so don't assume a
# 1 or a 0 return code here, could be either depending on if
# errors were generated or not
output = []
raw_lines = stdout.split("\n")
while raw_lines:
e = raw_lines.pop(0)
if re.match(r".+\.py:\d+: error: .*", e):
output.append(("error", e))
elif re.match(
r".+\.py:\d+: note: +(?:Possible overload|def ).*", e
):
while raw_lines:
ol = raw_lines.pop(0)
if not re.match(r".+\.py:\d+: note: +def \[.*", ol):
break
elif re.match(
r".+\.py:\d+: note: .*(?:perhaps|suggestion)", e, re.I
):
pass
elif re.match(r".+\.py:\d+: note: .*", e):
output.append(("note", e))
for num, is_mypy, is_re, msg in expected_messages:
msg = msg.replace("'", '"')
prefix = "[SQLAlchemy Mypy plugin] " if not is_mypy else ""
for idx, (typ, errmsg) in enumerate(output):
if is_re:
if re.match(
rf".*{filename}\:{num}\: {typ}\: {prefix}{msg}",
errmsg,
):
break
elif (
f"{filename}:{num}: {typ}: {prefix}{msg}"
in errmsg.replace("'", '"')
):
break
else:
not_located.append(msg)
continue
del output[idx]
if not_located:
missing = "\n".join(not_located)
print("Couldn't locate expected messages:", missing, sep="\n")
if output:
extra = "\n".join(msg for _, msg in output)
print("Remaining messages:", extra, sep="\n")
assert False, "expected messages not found, see stdout"
if output:
print(f"{len(output)} messages from mypy were not consumed:")
print("\n".join(msg for _, msg in output))
assert False, "errors and/or notes remain, see stdout"
else:
if exitcode != 0:
print(stdout, stderr, sep="\n")
eq_(exitcode, 0, msg=stdout)
|