Tipragot
628be439b8
Cela permet de ne pas avoir de problèmes de compatibilité car python est dans le git.
829 lines
29 KiB
Python
829 lines
29 KiB
Python
"""Utility functions with no non-trivial dependencies."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import io
|
|
import os
|
|
import pathlib
|
|
import re
|
|
import shutil
|
|
import sys
|
|
import time
|
|
from importlib import resources as importlib_resources
|
|
from typing import IO, Callable, Container, Final, Iterable, Sequence, Sized, TypeVar
|
|
from typing_extensions import Literal
|
|
|
|
try:
|
|
import curses
|
|
|
|
import _curses # noqa: F401
|
|
|
|
CURSES_ENABLED = True
|
|
except ImportError:
|
|
CURSES_ENABLED = False
|
|
|
|
T = TypeVar("T")
|
|
|
|
if sys.version_info >= (3, 9):
|
|
TYPESHED_DIR: Final = str(importlib_resources.files("mypy") / "typeshed")
|
|
else:
|
|
with importlib_resources.path(
|
|
"mypy", # mypy-c doesn't support __package__
|
|
"py.typed", # a marker file for type information, we assume typeshed to live in the same dir
|
|
) as _resource:
|
|
TYPESHED_DIR = str(_resource.parent / "typeshed")
|
|
|
|
|
|
ENCODING_RE: Final = re.compile(rb"([ \t\v]*#.*(\r\n?|\n))??[ \t\v]*#.*coding[:=][ \t]*([-\w.]+)")
|
|
|
|
DEFAULT_SOURCE_OFFSET: Final = 4
|
|
DEFAULT_COLUMNS: Final = 80
|
|
|
|
# At least this number of columns will be shown on each side of
|
|
# error location when printing source code snippet.
|
|
MINIMUM_WIDTH: Final = 20
|
|
|
|
# VT100 color code processing was added in Windows 10, but only the second major update,
|
|
# Threshold 2. Fortunately, everyone (even on LTSB, Long Term Support Branch) should
|
|
# have a version of Windows 10 newer than this. Note that Windows 8 and below are not
|
|
# supported, but are either going out of support, or make up only a few % of the market.
|
|
MINIMUM_WINDOWS_MAJOR_VT100: Final = 10
|
|
MINIMUM_WINDOWS_BUILD_VT100: Final = 10586
|
|
|
|
SPECIAL_DUNDERS: Final = frozenset(
|
|
("__init__", "__new__", "__call__", "__init_subclass__", "__class_getitem__")
|
|
)
|
|
|
|
|
|
def is_dunder(name: str, exclude_special: bool = False) -> bool:
|
|
"""Returns whether name is a dunder name.
|
|
|
|
Args:
|
|
exclude_special: Whether to return False for a couple special dunder methods.
|
|
|
|
"""
|
|
if exclude_special and name in SPECIAL_DUNDERS:
|
|
return False
|
|
return name.startswith("__") and name.endswith("__")
|
|
|
|
|
|
def is_sunder(name: str) -> bool:
|
|
return not is_dunder(name) and name.startswith("_") and name.endswith("_")
|
|
|
|
|
|
def split_module_names(mod_name: str) -> list[str]:
|
|
"""Return the module and all parent module names.
|
|
|
|
So, if `mod_name` is 'a.b.c', this function will return
|
|
['a.b.c', 'a.b', and 'a'].
|
|
"""
|
|
out = [mod_name]
|
|
while "." in mod_name:
|
|
mod_name = mod_name.rsplit(".", 1)[0]
|
|
out.append(mod_name)
|
|
return out
|
|
|
|
|
|
def module_prefix(modules: Iterable[str], target: str) -> str | None:
|
|
result = split_target(modules, target)
|
|
if result is None:
|
|
return None
|
|
return result[0]
|
|
|
|
|
|
def split_target(modules: Iterable[str], target: str) -> tuple[str, str] | None:
|
|
remaining: list[str] = []
|
|
while True:
|
|
if target in modules:
|
|
return target, ".".join(remaining)
|
|
components = target.rsplit(".", 1)
|
|
if len(components) == 1:
|
|
return None
|
|
target = components[0]
|
|
remaining.insert(0, components[1])
|
|
|
|
|
|
def short_type(obj: object) -> str:
|
|
"""Return the last component of the type name of an object.
|
|
|
|
If obj is None, return 'nil'. For example, if obj is 1, return 'int'.
|
|
"""
|
|
if obj is None:
|
|
return "nil"
|
|
t = str(type(obj))
|
|
return t.split(".")[-1].rstrip("'>")
|
|
|
|
|
|
def find_python_encoding(text: bytes) -> tuple[str, int]:
|
|
"""PEP-263 for detecting Python file encoding"""
|
|
result = ENCODING_RE.match(text)
|
|
if result:
|
|
line = 2 if result.group(1) else 1
|
|
encoding = result.group(3).decode("ascii")
|
|
# Handle some aliases that Python is happy to accept and that are used in the wild.
|
|
if encoding.startswith(("iso-latin-1-", "latin-1-")) or encoding == "iso-latin-1":
|
|
encoding = "latin-1"
|
|
return encoding, line
|
|
else:
|
|
default_encoding = "utf8"
|
|
return default_encoding, -1
|
|
|
|
|
|
def bytes_to_human_readable_repr(b: bytes) -> str:
|
|
"""Converts bytes into some human-readable representation. Unprintable
|
|
bytes such as the nul byte are escaped. For example:
|
|
|
|
>>> b = bytes([102, 111, 111, 10, 0])
|
|
>>> s = bytes_to_human_readable_repr(b)
|
|
>>> print(s)
|
|
foo\n\x00
|
|
>>> print(repr(s))
|
|
'foo\\n\\x00'
|
|
"""
|
|
return repr(b)[2:-1]
|
|
|
|
|
|
class DecodeError(Exception):
|
|
"""Exception raised when a file cannot be decoded due to an unknown encoding type.
|
|
|
|
Essentially a wrapper for the LookupError raised by `bytearray.decode`
|
|
"""
|
|
|
|
|
|
def decode_python_encoding(source: bytes) -> str:
|
|
"""Read the Python file with while obeying PEP-263 encoding detection.
|
|
|
|
Returns the source as a string.
|
|
"""
|
|
# check for BOM UTF-8 encoding and strip it out if present
|
|
if source.startswith(b"\xef\xbb\xbf"):
|
|
encoding = "utf8"
|
|
source = source[3:]
|
|
else:
|
|
# look at first two lines and check if PEP-263 coding is present
|
|
encoding, _ = find_python_encoding(source)
|
|
|
|
try:
|
|
source_text = source.decode(encoding)
|
|
except LookupError as lookuperr:
|
|
raise DecodeError(str(lookuperr)) from lookuperr
|
|
return source_text
|
|
|
|
|
|
def read_py_file(path: str, read: Callable[[str], bytes]) -> list[str] | None:
|
|
"""Try reading a Python file as list of source lines.
|
|
|
|
Return None if something goes wrong.
|
|
"""
|
|
try:
|
|
source = read(path)
|
|
except OSError:
|
|
return None
|
|
else:
|
|
try:
|
|
source_lines = decode_python_encoding(source).splitlines()
|
|
except DecodeError:
|
|
return None
|
|
return source_lines
|
|
|
|
|
|
def trim_source_line(line: str, max_len: int, col: int, min_width: int) -> tuple[str, int]:
|
|
"""Trim a line of source code to fit into max_len.
|
|
|
|
Show 'min_width' characters on each side of 'col' (an error location). If either
|
|
start or end is trimmed, this is indicated by adding '...' there.
|
|
A typical result looks like this:
|
|
...some_variable = function_to_call(one_arg, other_arg) or...
|
|
|
|
Return the trimmed string and the column offset to to adjust error location.
|
|
"""
|
|
if max_len < 2 * min_width + 1:
|
|
# In case the window is too tiny it is better to still show something.
|
|
max_len = 2 * min_width + 1
|
|
|
|
# Trivial case: line already fits in.
|
|
if len(line) <= max_len:
|
|
return line, 0
|
|
|
|
# If column is not too large so that there is still min_width after it,
|
|
# the line doesn't need to be trimmed at the start.
|
|
if col + min_width < max_len:
|
|
return line[:max_len] + "...", 0
|
|
|
|
# Otherwise, if the column is not too close to the end, trim both sides.
|
|
if col < len(line) - min_width - 1:
|
|
offset = col - max_len + min_width + 1
|
|
return "..." + line[offset : col + min_width + 1] + "...", offset - 3
|
|
|
|
# Finally, if the column is near the end, just trim the start.
|
|
return "..." + line[-max_len:], len(line) - max_len - 3
|
|
|
|
|
|
def get_mypy_comments(source: str) -> list[tuple[int, str]]:
|
|
PREFIX = "# mypy: "
|
|
# Don't bother splitting up the lines unless we know it is useful
|
|
if PREFIX not in source:
|
|
return []
|
|
lines = source.split("\n")
|
|
results = []
|
|
for i, line in enumerate(lines):
|
|
if line.startswith(PREFIX):
|
|
results.append((i + 1, line[len(PREFIX) :]))
|
|
|
|
return results
|
|
|
|
|
|
PASS_TEMPLATE: Final = """<?xml version="1.0" encoding="utf-8"?>
|
|
<testsuite errors="0" failures="0" name="mypy" skips="0" tests="1" time="{time:.3f}">
|
|
<testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
|
|
</testcase>
|
|
</testsuite>
|
|
"""
|
|
|
|
FAIL_TEMPLATE: Final = """<?xml version="1.0" encoding="utf-8"?>
|
|
<testsuite errors="0" failures="1" name="mypy" skips="0" tests="1" time="{time:.3f}">
|
|
<testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
|
|
<failure message="mypy produced messages">{text}</failure>
|
|
</testcase>
|
|
</testsuite>
|
|
"""
|
|
|
|
ERROR_TEMPLATE: Final = """<?xml version="1.0" encoding="utf-8"?>
|
|
<testsuite errors="1" failures="0" name="mypy" skips="0" tests="1" time="{time:.3f}">
|
|
<testcase classname="mypy" file="mypy" line="1" name="mypy-py{ver}-{platform}" time="{time:.3f}">
|
|
<error message="mypy produced errors">{text}</error>
|
|
</testcase>
|
|
</testsuite>
|
|
"""
|
|
|
|
|
|
def write_junit_xml(
|
|
dt: float, serious: bool, messages: list[str], path: str, version: str, platform: str
|
|
) -> None:
|
|
from xml.sax.saxutils import escape
|
|
|
|
if not messages and not serious:
|
|
xml = PASS_TEMPLATE.format(time=dt, ver=version, platform=platform)
|
|
elif not serious:
|
|
xml = FAIL_TEMPLATE.format(
|
|
text=escape("\n".join(messages)), time=dt, ver=version, platform=platform
|
|
)
|
|
else:
|
|
xml = ERROR_TEMPLATE.format(
|
|
text=escape("\n".join(messages)), time=dt, ver=version, platform=platform
|
|
)
|
|
|
|
# checks for a directory structure in path and creates folders if needed
|
|
xml_dirs = os.path.dirname(os.path.abspath(path))
|
|
if not os.path.isdir(xml_dirs):
|
|
os.makedirs(xml_dirs)
|
|
|
|
with open(path, "wb") as f:
|
|
f.write(xml.encode("utf-8"))
|
|
|
|
|
|
class IdMapper:
|
|
"""Generate integer ids for objects.
|
|
|
|
Unlike id(), these start from 0 and increment by 1, and ids won't
|
|
get reused across the life-time of IdMapper.
|
|
|
|
Assume objects don't redefine __eq__ or __hash__.
|
|
"""
|
|
|
|
def __init__(self) -> None:
|
|
self.id_map: dict[object, int] = {}
|
|
self.next_id = 0
|
|
|
|
def id(self, o: object) -> int:
|
|
if o not in self.id_map:
|
|
self.id_map[o] = self.next_id
|
|
self.next_id += 1
|
|
return self.id_map[o]
|
|
|
|
|
|
def get_prefix(fullname: str) -> str:
|
|
"""Drop the final component of a qualified name (e.g. ('x.y' -> 'x')."""
|
|
return fullname.rsplit(".", 1)[0]
|
|
|
|
|
|
def correct_relative_import(
|
|
cur_mod_id: str, relative: int, target: str, is_cur_package_init_file: bool
|
|
) -> tuple[str, bool]:
|
|
if relative == 0:
|
|
return target, True
|
|
parts = cur_mod_id.split(".")
|
|
rel = relative
|
|
if is_cur_package_init_file:
|
|
rel -= 1
|
|
ok = len(parts) >= rel
|
|
if rel != 0:
|
|
cur_mod_id = ".".join(parts[:-rel])
|
|
return cur_mod_id + (("." + target) if target else ""), ok
|
|
|
|
|
|
fields_cache: Final[dict[type[object], list[str]]] = {}
|
|
|
|
|
|
def get_class_descriptors(cls: type[object]) -> Sequence[str]:
|
|
import inspect # Lazy import for minor startup speed win
|
|
|
|
# Maintain a cache of type -> attributes defined by descriptors in the class
|
|
# (that is, attributes from __slots__ and C extension classes)
|
|
if cls not in fields_cache:
|
|
members = inspect.getmembers(
|
|
cls, lambda o: inspect.isgetsetdescriptor(o) or inspect.ismemberdescriptor(o)
|
|
)
|
|
fields_cache[cls] = [x for x, y in members if x != "__weakref__" and x != "__dict__"]
|
|
return fields_cache[cls]
|
|
|
|
|
|
def replace_object_state(
|
|
new: object, old: object, copy_dict: bool = False, skip_slots: tuple[str, ...] = ()
|
|
) -> None:
|
|
"""Copy state of old node to the new node.
|
|
|
|
This handles cases where there is __dict__ and/or attribute descriptors
|
|
(either from slots or because the type is defined in a C extension module).
|
|
|
|
Assume that both objects have the same __class__.
|
|
"""
|
|
if hasattr(old, "__dict__"):
|
|
if copy_dict:
|
|
new.__dict__ = dict(old.__dict__)
|
|
else:
|
|
new.__dict__ = old.__dict__
|
|
|
|
for attr in get_class_descriptors(old.__class__):
|
|
if attr in skip_slots:
|
|
continue
|
|
try:
|
|
if hasattr(old, attr):
|
|
setattr(new, attr, getattr(old, attr))
|
|
elif hasattr(new, attr):
|
|
delattr(new, attr)
|
|
# There is no way to distinguish getsetdescriptors that allow
|
|
# writes from ones that don't (I think?), so we just ignore
|
|
# AttributeErrors if we need to.
|
|
# TODO: What about getsetdescriptors that act like properties???
|
|
except AttributeError:
|
|
pass
|
|
|
|
|
|
def is_sub_path(path1: str, path2: str) -> bool:
|
|
"""Given two paths, return if path1 is a sub-path of path2."""
|
|
return pathlib.Path(path2) in pathlib.Path(path1).parents
|
|
|
|
|
|
def hard_exit(status: int = 0) -> None:
|
|
"""Kill the current process without fully cleaning up.
|
|
|
|
This can be quite a bit faster than a normal exit() since objects are not freed.
|
|
"""
|
|
sys.stdout.flush()
|
|
sys.stderr.flush()
|
|
os._exit(status)
|
|
|
|
|
|
def unmangle(name: str) -> str:
|
|
"""Remove internal suffixes from a short name."""
|
|
return name.rstrip("'")
|
|
|
|
|
|
def get_unique_redefinition_name(name: str, existing: Container[str]) -> str:
|
|
"""Get a simple redefinition name not present among existing.
|
|
|
|
For example, for name 'foo' we try 'foo-redefinition', 'foo-redefinition2',
|
|
'foo-redefinition3', etc. until we find one that is not in existing.
|
|
"""
|
|
r_name = name + "-redefinition"
|
|
if r_name not in existing:
|
|
return r_name
|
|
|
|
i = 2
|
|
while r_name + str(i) in existing:
|
|
i += 1
|
|
return r_name + str(i)
|
|
|
|
|
|
def check_python_version(program: str) -> None:
|
|
"""Report issues with the Python used to run mypy, dmypy, or stubgen"""
|
|
# Check for known bad Python versions.
|
|
if sys.version_info[:2] < (3, 8):
|
|
sys.exit(
|
|
"Running {name} with Python 3.7 or lower is not supported; "
|
|
"please upgrade to 3.8 or newer".format(name=program)
|
|
)
|
|
|
|
|
|
def count_stats(messages: list[str]) -> tuple[int, int, int]:
|
|
"""Count total number of errors, notes and error_files in message list."""
|
|
errors = [e for e in messages if ": error:" in e]
|
|
error_files = {e.split(":")[0] for e in errors}
|
|
notes = [e for e in messages if ": note:" in e]
|
|
return len(errors), len(notes), len(error_files)
|
|
|
|
|
|
def split_words(msg: str) -> list[str]:
|
|
"""Split line of text into words (but not within quoted groups)."""
|
|
next_word = ""
|
|
res: list[str] = []
|
|
allow_break = True
|
|
for c in msg:
|
|
if c == " " and allow_break:
|
|
res.append(next_word)
|
|
next_word = ""
|
|
continue
|
|
if c == '"':
|
|
allow_break = not allow_break
|
|
next_word += c
|
|
res.append(next_word)
|
|
return res
|
|
|
|
|
|
def get_terminal_width() -> int:
|
|
"""Get current terminal width if possible, otherwise return the default one."""
|
|
return (
|
|
int(os.getenv("MYPY_FORCE_TERMINAL_WIDTH", "0"))
|
|
or shutil.get_terminal_size().columns
|
|
or DEFAULT_COLUMNS
|
|
)
|
|
|
|
|
|
def soft_wrap(msg: str, max_len: int, first_offset: int, num_indent: int = 0) -> str:
|
|
"""Wrap a long error message into few lines.
|
|
|
|
Breaks will only happen between words, and never inside a quoted group
|
|
(to avoid breaking types such as "Union[int, str]"). The 'first_offset' is
|
|
the width before the start of first line.
|
|
|
|
Pad every next line with 'num_indent' spaces. Every line will be at most 'max_len'
|
|
characters, except if it is a single word or quoted group.
|
|
|
|
For example:
|
|
first_offset
|
|
------------------------
|
|
path/to/file: error: 58: Some very long error message
|
|
that needs to be split in separate lines.
|
|
"Long[Type, Names]" are never split.
|
|
^^^^--------------------------------------------------
|
|
num_indent max_len
|
|
"""
|
|
words = split_words(msg)
|
|
next_line = words.pop(0)
|
|
lines: list[str] = []
|
|
while words:
|
|
next_word = words.pop(0)
|
|
max_line_len = max_len - num_indent if lines else max_len - first_offset
|
|
# Add 1 to account for space between words.
|
|
if len(next_line) + len(next_word) + 1 <= max_line_len:
|
|
next_line += " " + next_word
|
|
else:
|
|
lines.append(next_line)
|
|
next_line = next_word
|
|
lines.append(next_line)
|
|
padding = "\n" + " " * num_indent
|
|
return padding.join(lines)
|
|
|
|
|
|
def hash_digest(data: bytes) -> str:
|
|
"""Compute a hash digest of some data.
|
|
|
|
We use a cryptographic hash because we want a low probability of
|
|
accidental collision, but we don't really care about any of the
|
|
cryptographic properties.
|
|
"""
|
|
# Once we drop Python 3.5 support, we should consider using
|
|
# blake2b, which is faster.
|
|
return hashlib.sha256(data).hexdigest()
|
|
|
|
|
|
def parse_gray_color(cup: bytes) -> str:
|
|
"""Reproduce a gray color in ANSI escape sequence"""
|
|
if sys.platform == "win32":
|
|
assert False, "curses is not available on Windows"
|
|
set_color = "".join([cup[:-1].decode(), "m"])
|
|
gray = curses.tparm(set_color.encode("utf-8"), 1, 9).decode()
|
|
return gray
|
|
|
|
|
|
def should_force_color() -> bool:
|
|
env_var = os.getenv("MYPY_FORCE_COLOR", os.getenv("FORCE_COLOR", "0"))
|
|
try:
|
|
return bool(int(env_var))
|
|
except ValueError:
|
|
return bool(env_var)
|
|
|
|
|
|
class FancyFormatter:
|
|
"""Apply color and bold font to terminal output.
|
|
|
|
This currently only works on Linux and Mac.
|
|
"""
|
|
|
|
def __init__(self, f_out: IO[str], f_err: IO[str], hide_error_codes: bool) -> None:
|
|
self.hide_error_codes = hide_error_codes
|
|
# Check if we are in a human-facing terminal on a supported platform.
|
|
if sys.platform not in ("linux", "darwin", "win32", "emscripten"):
|
|
self.dummy_term = True
|
|
return
|
|
if not should_force_color() and (not f_out.isatty() or not f_err.isatty()):
|
|
self.dummy_term = True
|
|
return
|
|
if sys.platform == "win32":
|
|
self.dummy_term = not self.initialize_win_colors()
|
|
elif sys.platform == "emscripten":
|
|
self.dummy_term = not self.initialize_vt100_colors()
|
|
else:
|
|
self.dummy_term = not self.initialize_unix_colors()
|
|
if not self.dummy_term:
|
|
self.colors = {
|
|
"red": self.RED,
|
|
"green": self.GREEN,
|
|
"blue": self.BLUE,
|
|
"yellow": self.YELLOW,
|
|
"none": "",
|
|
}
|
|
|
|
def initialize_vt100_colors(self) -> bool:
|
|
"""Return True if initialization was successful and we can use colors, False otherwise"""
|
|
# Windows and Emscripten can both use ANSI/VT100 escape sequences for color
|
|
assert sys.platform in ("win32", "emscripten")
|
|
self.BOLD = "\033[1m"
|
|
self.UNDER = "\033[4m"
|
|
self.BLUE = "\033[94m"
|
|
self.GREEN = "\033[92m"
|
|
self.RED = "\033[91m"
|
|
self.YELLOW = "\033[93m"
|
|
self.NORMAL = "\033[0m"
|
|
self.DIM = "\033[2m"
|
|
return True
|
|
|
|
def initialize_win_colors(self) -> bool:
|
|
"""Return True if initialization was successful and we can use colors, False otherwise"""
|
|
# Windows ANSI escape sequences are only supported on Threshold 2 and above.
|
|
# we check with an assert at runtime and an if check for mypy, as asserts do not
|
|
# yet narrow platform
|
|
assert sys.platform == "win32"
|
|
if sys.platform == "win32":
|
|
winver = sys.getwindowsversion()
|
|
if (
|
|
winver.major < MINIMUM_WINDOWS_MAJOR_VT100
|
|
or winver.build < MINIMUM_WINDOWS_BUILD_VT100
|
|
):
|
|
return False
|
|
import ctypes
|
|
|
|
kernel32 = ctypes.windll.kernel32
|
|
ENABLE_PROCESSED_OUTPUT = 0x1
|
|
ENABLE_WRAP_AT_EOL_OUTPUT = 0x2
|
|
ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4
|
|
STD_OUTPUT_HANDLE = -11
|
|
kernel32.SetConsoleMode(
|
|
kernel32.GetStdHandle(STD_OUTPUT_HANDLE),
|
|
ENABLE_PROCESSED_OUTPUT
|
|
| ENABLE_WRAP_AT_EOL_OUTPUT
|
|
| ENABLE_VIRTUAL_TERMINAL_PROCESSING,
|
|
)
|
|
self.initialize_vt100_colors()
|
|
return True
|
|
return False
|
|
|
|
def initialize_unix_colors(self) -> bool:
|
|
"""Return True if initialization was successful and we can use colors, False otherwise"""
|
|
if sys.platform == "win32" or not CURSES_ENABLED:
|
|
return False
|
|
try:
|
|
# setupterm wants a fd to potentially write an "initialization sequence".
|
|
# We override sys.stdout for the daemon API so if stdout doesn't have an fd,
|
|
# just give it /dev/null.
|
|
try:
|
|
fd = sys.stdout.fileno()
|
|
except io.UnsupportedOperation:
|
|
with open("/dev/null", "rb") as f:
|
|
curses.setupterm(fd=f.fileno())
|
|
else:
|
|
curses.setupterm(fd=fd)
|
|
except curses.error:
|
|
# Most likely terminfo not found.
|
|
return False
|
|
bold = curses.tigetstr("bold")
|
|
under = curses.tigetstr("smul")
|
|
set_color = curses.tigetstr("setaf")
|
|
set_eseq = curses.tigetstr("cup")
|
|
normal = curses.tigetstr("sgr0")
|
|
|
|
if not (bold and under and set_color and set_eseq and normal):
|
|
return False
|
|
|
|
self.NORMAL = normal.decode()
|
|
self.BOLD = bold.decode()
|
|
self.UNDER = under.decode()
|
|
self.DIM = parse_gray_color(set_eseq)
|
|
self.BLUE = curses.tparm(set_color, curses.COLOR_BLUE).decode()
|
|
self.GREEN = curses.tparm(set_color, curses.COLOR_GREEN).decode()
|
|
self.RED = curses.tparm(set_color, curses.COLOR_RED).decode()
|
|
self.YELLOW = curses.tparm(set_color, curses.COLOR_YELLOW).decode()
|
|
return True
|
|
|
|
def style(
|
|
self,
|
|
text: str,
|
|
color: Literal["red", "green", "blue", "yellow", "none"],
|
|
bold: bool = False,
|
|
underline: bool = False,
|
|
dim: bool = False,
|
|
) -> str:
|
|
"""Apply simple color and style (underlined or bold)."""
|
|
if self.dummy_term:
|
|
return text
|
|
if bold:
|
|
start = self.BOLD
|
|
else:
|
|
start = ""
|
|
if underline:
|
|
start += self.UNDER
|
|
if dim:
|
|
start += self.DIM
|
|
return start + self.colors[color] + text + self.NORMAL
|
|
|
|
def fit_in_terminal(
|
|
self, messages: list[str], fixed_terminal_width: int | None = None
|
|
) -> list[str]:
|
|
"""Improve readability by wrapping error messages and trimming source code."""
|
|
width = fixed_terminal_width or get_terminal_width()
|
|
new_messages = messages.copy()
|
|
for i, error in enumerate(messages):
|
|
if ": error:" in error:
|
|
loc, msg = error.split("error:", maxsplit=1)
|
|
msg = soft_wrap(msg, width, first_offset=len(loc) + len("error: "))
|
|
new_messages[i] = loc + "error:" + msg
|
|
if error.startswith(" " * DEFAULT_SOURCE_OFFSET) and "^" not in error:
|
|
# TODO: detecting source code highlights through an indent can be surprising.
|
|
# Restore original error message and error location.
|
|
error = error[DEFAULT_SOURCE_OFFSET:]
|
|
marker_line = messages[i + 1]
|
|
marker_column = marker_line.index("^")
|
|
column = marker_column - DEFAULT_SOURCE_OFFSET
|
|
if "~" not in marker_line:
|
|
marker = "^"
|
|
else:
|
|
# +1 because both ends are included
|
|
marker = marker_line[marker_column : marker_line.rindex("~") + 1]
|
|
|
|
# Let source have some space also on the right side, plus 6
|
|
# to accommodate ... on each side.
|
|
max_len = width - DEFAULT_SOURCE_OFFSET - 6
|
|
source_line, offset = trim_source_line(error, max_len, column, MINIMUM_WIDTH)
|
|
|
|
new_messages[i] = " " * DEFAULT_SOURCE_OFFSET + source_line
|
|
# Also adjust the error marker position and trim error marker is needed.
|
|
new_marker_line = " " * (DEFAULT_SOURCE_OFFSET + column - offset) + marker
|
|
if len(new_marker_line) > len(new_messages[i]) and len(marker) > 3:
|
|
new_marker_line = new_marker_line[: len(new_messages[i]) - 3] + "..."
|
|
new_messages[i + 1] = new_marker_line
|
|
return new_messages
|
|
|
|
def colorize(self, error: str) -> str:
|
|
"""Colorize an output line by highlighting the status and error code."""
|
|
if ": error:" in error:
|
|
loc, msg = error.split("error:", maxsplit=1)
|
|
if self.hide_error_codes:
|
|
return (
|
|
loc + self.style("error:", "red", bold=True) + self.highlight_quote_groups(msg)
|
|
)
|
|
codepos = msg.rfind("[")
|
|
if codepos != -1:
|
|
code = msg[codepos:]
|
|
msg = msg[:codepos]
|
|
else:
|
|
code = "" # no error code specified
|
|
return (
|
|
loc
|
|
+ self.style("error:", "red", bold=True)
|
|
+ self.highlight_quote_groups(msg)
|
|
+ self.style(code, "yellow")
|
|
)
|
|
elif ": note:" in error:
|
|
loc, msg = error.split("note:", maxsplit=1)
|
|
formatted = self.highlight_quote_groups(self.underline_link(msg))
|
|
return loc + self.style("note:", "blue") + formatted
|
|
elif error.startswith(" " * DEFAULT_SOURCE_OFFSET):
|
|
# TODO: detecting source code highlights through an indent can be surprising.
|
|
if "^" not in error:
|
|
return self.style(error, "none", dim=True)
|
|
return self.style(error, "red")
|
|
else:
|
|
return error
|
|
|
|
def highlight_quote_groups(self, msg: str) -> str:
|
|
"""Make groups quoted with double quotes bold (including quotes).
|
|
|
|
This is used to highlight types, attribute names etc.
|
|
"""
|
|
if msg.count('"') % 2:
|
|
# Broken error message, don't do any formatting.
|
|
return msg
|
|
parts = msg.split('"')
|
|
out = ""
|
|
for i, part in enumerate(parts):
|
|
if i % 2 == 0:
|
|
out += self.style(part, "none")
|
|
else:
|
|
out += self.style('"' + part + '"', "none", bold=True)
|
|
return out
|
|
|
|
def underline_link(self, note: str) -> str:
|
|
"""Underline a link in a note message (if any).
|
|
|
|
This assumes there is at most one link in the message.
|
|
"""
|
|
match = re.search(r"https?://\S*", note)
|
|
if not match:
|
|
return note
|
|
start = match.start()
|
|
end = match.end()
|
|
return note[:start] + self.style(note[start:end], "none", underline=True) + note[end:]
|
|
|
|
def format_success(self, n_sources: int, use_color: bool = True) -> str:
|
|
"""Format short summary in case of success.
|
|
|
|
n_sources is total number of files passed directly on command line,
|
|
i.e. excluding stubs and followed imports.
|
|
"""
|
|
msg = f"Success: no issues found in {n_sources} source file{plural_s(n_sources)}"
|
|
if not use_color:
|
|
return msg
|
|
return self.style(msg, "green", bold=True)
|
|
|
|
def format_error(
|
|
self,
|
|
n_errors: int,
|
|
n_files: int,
|
|
n_sources: int,
|
|
*,
|
|
blockers: bool = False,
|
|
use_color: bool = True,
|
|
) -> str:
|
|
"""Format a short summary in case of errors."""
|
|
msg = f"Found {n_errors} error{plural_s(n_errors)} in {n_files} file{plural_s(n_files)}"
|
|
if blockers:
|
|
msg += " (errors prevented further checking)"
|
|
else:
|
|
msg += f" (checked {n_sources} source file{plural_s(n_sources)})"
|
|
if not use_color:
|
|
return msg
|
|
return self.style(msg, "red", bold=True)
|
|
|
|
|
|
def is_typeshed_file(typeshed_dir: str | None, file: str) -> bool:
|
|
typeshed_dir = typeshed_dir if typeshed_dir is not None else TYPESHED_DIR
|
|
try:
|
|
return os.path.commonpath((typeshed_dir, os.path.abspath(file))) == typeshed_dir
|
|
except ValueError: # Different drives on Windows
|
|
return False
|
|
|
|
|
|
def is_stub_package_file(file: str) -> bool:
|
|
# Use hacky heuristics to check whether file is part of a PEP 561 stub package.
|
|
if not file.endswith(".pyi"):
|
|
return False
|
|
return any(component.endswith("-stubs") for component in os.path.split(os.path.abspath(file)))
|
|
|
|
|
|
def unnamed_function(name: str | None) -> bool:
|
|
return name is not None and name == "_"
|
|
|
|
|
|
time_ref = time.perf_counter_ns
|
|
|
|
|
|
def time_spent_us(t0: int) -> int:
|
|
return int((time.perf_counter_ns() - t0) / 1000)
|
|
|
|
|
|
def plural_s(s: int | Sized) -> str:
|
|
count = s if isinstance(s, int) else len(s)
|
|
if count != 1:
|
|
return "s"
|
|
else:
|
|
return ""
|
|
|
|
|
|
def quote_docstring(docstr: str) -> str:
|
|
"""Returns docstring correctly encapsulated in a single or double quoted form."""
|
|
# Uses repr to get hint on the correct quotes and escape everything properly.
|
|
# Creating multiline string for prettier output.
|
|
docstr_repr = "\n".join(re.split(r"(?<=[^\\])\\n", repr(docstr)))
|
|
|
|
if docstr_repr.startswith("'"):
|
|
# Enforce double quotes when it's safe to do so.
|
|
# That is when double quotes are not in the string
|
|
# or when it doesn't end with a single quote.
|
|
if '"' not in docstr_repr[1:-1] and docstr_repr[-2] != "'":
|
|
return f'"""{docstr_repr[1:-1]}"""'
|
|
return f"''{docstr_repr}''"
|
|
else:
|
|
return f'""{docstr_repr}""'
|