3932668511

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/psf/black/commit/<a class=hub.com/psf/black/commit/92953c87f43951fc032b617a4ebbd9c04e50f8e6">92953c87f<a href="https://github.com/psf/black/commit/92953c87f43951fc032b617a4ebbd9c04e50f8e6">">Merge </a><a class="double-link" href="https://github.com/psf/black/commit/<a class="double-link" href="https://github.com/psf/black/commit/9577e45e5d1a4a64cc4beb38a2aed358a072424d">9577e45e5</a>">9577e45e5</a><a href="https://github.com/psf/black/commit/92953c87f43951fc032b617a4ebbd9c04e50f8e6"> into d4ff98585">d4ff98585</a>

Pull Request Pull Request #3219: Infer target version based on project metadata

Run Details

69 of 70 new or added lines in 3 files covered. (98.57%)

6294 of 6560 relevant lines covered (95.95%)

6.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.75

/src/black/files.py

import io
import os
import sys
from functools import lru_cache
from pathlib import Path
from typing import (
    TYPE_CHECKING,
    Any,
    Dict,
    Iterable,
    Iterator,
    List,
    Optional,
    Pattern,
    Sequence,
    Tuple,
    Union,
)

from mypy_extensions import mypyc_attr
from packaging.specifiers import InvalidSpecifier, Specifier, SpecifierSet
from packaging.version import InvalidVersion, Version
from pathspec import PathSpec
from pathspec.patterns.gitwildmatch import GitWildMatchPatternError

if sys.version_info >= (3, 11):
    try:
        import tomllib
    except ImportError:
        # Help users on older alphas
        if not TYPE_CHECKING:
            import tomli as tomllib
else:
    import tomli as tomllib

from black.handle_ipynb_magics import jupyter_dependencies_are_installed
from black.mode import TargetVersion
from black.output import err
from black.report import Report

if TYPE_CHECKING:
    import colorama  # noqa: F401


@lru_cache()
def find_project_root(
    srcs: Sequence[str], stdin_filename: Optional[str] = None
) -> Tuple[Path, str]:
    """Return a directory containing .git, .hg, or pyproject.toml.

    That directory will be a common parent of all files and directories
    passed in `srcs`.

    If no directory in the tree contains a marker that would specify it's the
    project root, the root of the file system is returned.

    Returns a two-tuple with the first element as the project root path and
    the second element as a string describing the method by which the
    project root was discovered.
    """
    if stdin_filename is not None:
        srcs = tuple(stdin_filename if s == "-" else s for s in srcs)
    if not srcs:
        srcs = [str(Path.cwd().resolve())]

    path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]

    # A list of lists of parents for each 'src'. 'src' is included as a
    # "parent" of itself if it is a directory
    src_parents = [
        list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
    ]

    common_base = max(
        set.intersection(*(set(parents) for parents in src_parents)),
        key=lambda path: path.parts,
    )

    for directory in (common_base, *common_base.parents):
        if (directory / ".git").exists():
            return directory, ".git directory"

        if (directory / ".hg").is_dir():
            return directory, ".hg directory"

        if (directory / "pyproject.toml").is_file():
            return directory, "pyproject.toml"

    return directory, "file system root"


def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
    """Find the absolute filepath to a pyproject.toml if it exists"""
    path_project_root, _ = find_project_root(path_search_start)
    path_pyproject_toml = path_project_root / "pyproject.toml"
    if path_pyproject_toml.is_file():
        return str(path_pyproject_toml)

    try:
        path_user_pyproject_toml = find_user_pyproject_toml()
        return (
            str(path_user_pyproject_toml)
            if path_user_pyproject_toml.is_file()
            else None
        )
    except (PermissionError, RuntimeError) as e:
        # We do not have access to the user-level config directory, so ignore it.
        err(f"Ignoring user configuration directory due to {e!r}")
        return None


@mypyc_attr(patchable=True)
def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
    """Parse a pyproject toml file, pulling out relevant parts for Black.

    If parsing fails, will raise a tomllib.TOMLDecodeError.
    """
    with open(path_config, "rb") as f:
        pyproject_toml = tomllib.load(f)
    config: Dict[str, Any] = pyproject_toml.get("tool", {}).get("black", {})
    config = {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}

    if "target_version" not in config:
        inferred_target_version = infer_target_version(pyproject_toml)
        if inferred_target_version is not None:
            config["target_version"] = [v.name.lower() for v in inferred_target_version]

    return config


def infer_target_version(
    pyproject_toml: Dict[str, Any]
) -> Optional[List[TargetVersion]]:
    """Infer Black's target version from the project metadata in pyproject.toml.

    Supports the PyPA standard format (PEP 621):
    https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#requires-python

    If the target version cannot be inferred, returns None.
    """
    project_metadata = pyproject_toml.get("project", {})
    requires_python = project_metadata.get("requires-python", None)
    if requires_python is not None:
        try:
            return parse_req_python_version(requires_python)
        except InvalidVersion:
            pass
        try:
            return parse_req_python_specifier(requires_python)
        except (InvalidSpecifier, InvalidVersion):
            pass

    return None


def parse_req_python_version(requires_python: str) -> Optional[List[TargetVersion]]:
    """Parse a version string (i.e. ``"3.7"``) to a list of TargetVersion.

    If parsing fails, will raise a packaging.version.InvalidVersion error.
    If the parsed version cannot be mapped to a valid TargetVersion, returns None.
    """
    version = Version(requires_python)
    if version.release[0] != 3:
        return None
    try:
        return [TargetVersion(version.release[1])]
    except (IndexError, ValueError):
        return None


def parse_req_python_specifier(requires_python: str) -> Optional[List[TargetVersion]]:
    """Parse a specifier string (i.e. ``">=3.7,<3.10"``) to a list of TargetVersion.

    If parsing fails, will raise a packaging.specifiers.InvalidSpecifier error.
    If the parsed specifier cannot be mapped to a valid TargetVersion, returns None.
    """
    specifier_set = strip_specifier_set(SpecifierSet(requires_python))
    if not specifier_set:
        return None

    target_version_map = {f"3.{v.value}": v for v in TargetVersion}
    compatible_versions = list(specifier_set.filter(target_version_map))
    if compatible_versions:
        return [target_version_map[v] for v in compatible_versions]
    return None


def strip_specifier_set(specifier_set: SpecifierSet) -> SpecifierSet:
    """Strip minor versions for some specifiers in the specifier set.

    For background on version specifiers, see PEP 440:
    https://peps.python.org/pep-0440/#version-specifiers
    """
    specifiers = []
    for s in specifier_set:
        if not isinstance(s, Specifier):
            return SpecifierSet()

        if "*" in str(s):
            specifiers.append(s)
        elif s.operator in ["~=", "==", ">=", "==="]:
            version = Version(s.version)
            stripped = Specifier(f"{s.operator}{version.major}.{version.minor}")
            specifiers.append(stripped)
        elif s.operator == ">":
            version = Version(s.version)
            if len(version.release) > 2:
                s = Specifier(f">={version.major}.{version.minor}")
            specifiers.append(s)
        else:
            specifiers.append(s)

    return SpecifierSet(",".join(str(s) for s in specifiers))


@lru_cache()
def find_user_pyproject_toml() -> Path:
    r"""Return the path to the top-level user configuration for black.

    This looks for ~\.black on Windows and ~/.config/black on Linux and other
    Unix systems.

    May raise:
    - RuntimeError: if the current user has no homedir
    - PermissionError: if the current process cannot access the user's homedir
    """
    if sys.platform == "win32":
        # Windows
        user_config_path = Path.home() / ".black"
    else:
        config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config")
        user_config_path = Path(config_root).expanduser() / "black"
    return user_config_path.resolve()


@lru_cache()
def get_gitignore(root: Path) -> PathSpec:
    """Return a PathSpec matching gitignore content if present."""
    gitignore = root / ".gitignore"
    lines: List[str] = []
    if gitignore.is_file():
        with gitignore.open(encoding="utf-8") as gf:
            lines = gf.readlines()
    try:
        return PathSpec.from_lines("gitwildmatch", lines)
    except GitWildMatchPatternError as e:
        err(f"Could not parse {gitignore}: {e}")
        raise


def normalize_path_maybe_ignore(
    path: Path,
    root: Path,
    report: Optional[Report] = None,
) -> Optional[str]:
    """Normalize `path`. May return `None` if `path` was ignored.

    `report` is where "path ignored" output goes.
    """
    try:
        abspath = path if path.is_absolute() else Path.cwd() / path
        normalized_path = abspath.resolve()
        try:
            root_relative_path = normalized_path.relative_to(root).as_posix()
        except ValueError:
            if report:
                report.path_ignored(
                    path, f"is a symbolic link that points outside {root}"
                )
            return None

    except OSError as e:
        if report:
            report.path_ignored(path, f"cannot be read because {e}")
        return None

    return root_relative_path


def path_is_ignored(
    path: Path, gitignore_dict: Dict[Path, PathSpec], report: Report
) -> bool:
    for gitignore_path, pattern in gitignore_dict.items():
        relative_path = normalize_path_maybe_ignore(path, gitignore_path, report)
        if relative_path is None:
            break
        if pattern.match_file(relative_path):
            report.path_ignored(path, "matches a .gitignore file content")
            return True
    return False


def path_is_excluded(
    normalized_path: str,
    pattern: Optional[Pattern[str]],
) -> bool:
    match = pattern.search(normalized_path) if pattern else None
    return bool(match and match.group(0))


def gen_python_files(
    paths: Iterable[Path],
    root: Path,
    include: Pattern[str],
    exclude: Pattern[str],
    extend_exclude: Optional[Pattern[str]],
    force_exclude: Optional[Pattern[str]],
    report: Report,
    gitignore_dict: Optional[Dict[Path, PathSpec]],
    *,
    verbose: bool,
    quiet: bool,
) -> Iterator[Path]:
    """Generate all files under `path` whose paths are not excluded by the
    `exclude_regex`, `extend_exclude`, or `force_exclude` regexes,
    but are included by the `include` regex.

    Symbolic links pointing outside of the `root` directory are ignored.

    `report` is where output about exclusions goes.
    """

    assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
    for child in paths:
        normalized_path = normalize_path_maybe_ignore(child, root, report)
        if normalized_path is None:
            continue

        # First ignore files matching .gitignore, if passed
        if gitignore_dict and path_is_ignored(child, gitignore_dict, report):
            continue

        # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
        normalized_path = "/" + normalized_path
        if child.is_dir():
            normalized_path += "/"

        if path_is_excluded(normalized_path, exclude):
            report.path_ignored(child, "matches the --exclude regular expression")
            continue

        if path_is_excluded(normalized_path, extend_exclude):
            report.path_ignored(
                child, "matches the --extend-exclude regular expression"
            )
            continue

        if path_is_excluded(normalized_path, force_exclude):
            report.path_ignored(child, "matches the --force-exclude regular expression")
            continue

        if child.is_dir():
            # If gitignore is None, gitignore usage is disabled, while a Falsey
            # gitignore is when the directory doesn't have a .gitignore file.
            if gitignore_dict is not None:
                new_gitignore_dict = {
                    **gitignore_dict,
                    root / child: get_gitignore(child),
                }
            else:
                new_gitignore_dict = None
            yield from gen_python_files(
                child.iterdir(),
                root,
                include,
                exclude,
                extend_exclude,
                force_exclude,
                report,
                new_gitignore_dict,
                verbose=verbose,
                quiet=quiet,
            )

        elif child.is_file():
            if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed(
                verbose=verbose, quiet=quiet
            ):
                continue
            include_match = include.search(normalized_path) if include else True
            if include_match:
                yield child


def wrap_stream_for_windows(
    f: io.TextIOWrapper,
) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
    """
    Wrap stream with colorama's wrap_stream so colors are shown on Windows.

    If `colorama` is unavailable, the original stream is returned unmodified.
    Otherwise, the `wrap_stream()` function determines whether the stream needs
    to be wrapped for a Windows environment and will accordingly either return
    an `AnsiToWin32` wrapper or the original stream.
    """
    try:
        from colorama.initialise import wrap_stream
    except ImportError:
        return f
    else:
        # Set `strip=False` to avoid needing to modify test_express_diff_with_color.
        return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)

1	import io	7✔
2	import os	7✔
3	import sys	7✔
4	from functools import lru_cache	7✔
5	from pathlib import Path	7✔
6	from typing import (	7✔
7	TYPE_CHECKING,
8	Any,
9	Dict,
10	Iterable,
11	Iterator,
12	List,
13	Optional,
14	Pattern,
15	Sequence,
16	Tuple,
17	Union,
18	)
19
20	from mypy_extensions import mypyc_attr	7✔
21	from packaging.specifiers import InvalidSpecifier, Specifier, SpecifierSet	7✔
22	from packaging.version import InvalidVersion, Version	7✔
23	from pathspec import PathSpec	7✔
24	from pathspec.patterns.gitwildmatch import GitWildMatchPatternError	7✔
25
26	if sys.version_info >= (3, 11):	7✔
27	try:	1✔
28	import tomllib	1✔
29	except ImportError:	×
30	# Help users on older alphas
31	if not TYPE_CHECKING:	×
32	import tomli as tomllib	×
33	else:
34	import tomli as tomllib	6✔
35
36	from black.handle_ipynb_magics import jupyter_dependencies_are_installed	7✔
37	from black.mode import TargetVersion	7✔
38	from black.output import err	7✔
39	from black.report import Report	7✔
40
41	if TYPE_CHECKING:	7✔
42	import colorama # noqa: F401	×
43
44
45	@lru_cache()	7✔
46	def find_project_root(	7✔
47	srcs: Sequence[str], stdin_filename: Optional[str] = None
48	) -> Tuple[Path, str]:
49	"""Return a directory containing .git, .hg, or pyproject.toml.
50
51	That directory will be a common parent of all files and directories
52	passed in `srcs`.
53
54	If no directory in the tree contains a marker that would specify it's the
55	project root, the root of the file system is returned.
56
57	Returns a two-tuple with the first element as the project root path and
58	the second element as a string describing the method by which the
59	project root was discovered.
60	"""
61	if stdin_filename is not None:	7✔
62	srcs = tuple(stdin_filename if s == "-" else s for s in srcs)	7✔
63	if not srcs:	7✔
64	srcs = [str(Path.cwd().resolve())]	7✔
65
66	path_srcs = [Path(Path.cwd(), src).resolve() for src in srcs]	7✔
67
68	# A list of lists of parents for each 'src'. 'src' is included as a
69	# "parent" of itself if it is a directory
70	src_parents = [	7✔
71	list(path.parents) + ([path] if path.is_dir() else []) for path in path_srcs
72	]
73
74	common_base = max(	7✔
75	set.intersection(*(set(parents) for parents in src_parents)),
76	key=lambda path: path.parts,
77	)
78
79	for directory in (common_base, *common_base.parents):	7✔
80	if (directory / ".git").exists():	7✔
81	return directory, ".git directory"	7✔
82
83	if (directory / ".hg").is_dir():	7✔
84	return directory, ".hg directory"	×
85
86	if (directory / "pyproject.toml").is_file():	7✔
87	return directory, "pyproject.toml"	7✔
88
89	return directory, "file system root"	7✔
90
91
92	def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:	7✔
93	"""Find the absolute filepath to a pyproject.toml if it exists"""
94	path_project_root, _ = find_project_root(path_search_start)	7✔
95	path_pyproject_toml = path_project_root / "pyproject.toml"	7✔
96	if path_pyproject_toml.is_file():	7✔
97	return str(path_pyproject_toml)	7✔
98
99	try:	7✔
100	path_user_pyproject_toml = find_user_pyproject_toml()	7✔
101	return (	7✔
102	str(path_user_pyproject_toml)
103	if path_user_pyproject_toml.is_file()
104	else None
105	)
106	except (PermissionError, RuntimeError) as e:	7✔
107	# We do not have access to the user-level config directory, so ignore it.
108	err(f"Ignoring user configuration directory due to {e!r}")	7✔
109	return None	7✔
110
111
112	@mypyc_attr(patchable=True)	7✔
113	def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:	7✔
114	"""Parse a pyproject toml file, pulling out relevant parts for Black.
115
116	If parsing fails, will raise a tomllib.TOMLDecodeError.
117	"""
118	with open(path_config, "rb") as f:	7✔
119	pyproject_toml = tomllib.load(f)	7✔
120	config: Dict[str, Any] = pyproject_toml.get("tool", {}).get("black", {})	7✔
121	config = {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}	7✔
122
123	if "target_version" not in config:	7✔
124	inferred_target_version = infer_target_version(pyproject_toml)	7✔
125	if inferred_target_version is not None:	7✔
126	config["target_version"] = [v.name.lower() for v in inferred_target_version]	7✔
127
128	return config	7✔
129
130
131	def infer_target_version(	7✔
132	pyproject_toml: Dict[str, Any]
133	) -> Optional[List[TargetVersion]]:
134	"""Infer Black's target version from the project metadata in pyproject.toml.
135
136	Supports the PyPA standard format (PEP 621):
137	https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#requires-python
138
139	If the target version cannot be inferred, returns None.
140	"""
141	project_metadata = pyproject_toml.get("project", {})	7✔
142	requires_python = project_metadata.get("requires-python", None)	7✔
143	if requires_python is not None:	7✔
144	try:	7✔
145	return parse_req_python_version(requires_python)	7✔
146	except InvalidVersion:	7✔
147	pass	7✔
148	try:	7✔
149	return parse_req_python_specifier(requires_python)	7✔
150	except (InvalidSpecifier, InvalidVersion):	7✔
151	pass	7✔
152
153	return None	7✔
154
155
156	def parse_req_python_version(requires_python: str) -> Optional[List[TargetVersion]]:	7✔
157	"""Parse a version string (i.e. ``"3.7"``) to a list of TargetVersion.
158
159	If parsing fails, will raise a packaging.version.InvalidVersion error.
160	If the parsed version cannot be mapped to a valid TargetVersion, returns None.
161	"""
162	version = Version(requires_python)	7✔
163	if version.release[0] != 3:	7✔
164	return None	7✔
165	try:	7✔
166	return [TargetVersion(version.release[1])]	7✔
167	except (IndexError, ValueError):	7✔
168	return None	7✔
169
170
171	def parse_req_python_specifier(requires_python: str) -> Optional[List[TargetVersion]]:	7✔
172	"""Parse a specifier string (i.e. ``">=3.7,<3.10"``) to a list of TargetVersion.
173
174	If parsing fails, will raise a packaging.specifiers.InvalidSpecifier error.
175	If the parsed specifier cannot be mapped to a valid TargetVersion, returns None.
176	"""
177	specifier_set = strip_specifier_set(SpecifierSet(requires_python))	7✔
178	if not specifier_set:	7✔
179	return None	7✔
180
181	target_version_map = {f"3.{v.value}": v for v in TargetVersion}	7✔
182	compatible_versions = list(specifier_set.filter(target_version_map))	7✔
183	if compatible_versions:	7✔
184	return [target_version_map[v] for v in compatible_versions]	7✔
185	return None	7✔
186
187
188	def strip_specifier_set(specifier_set: SpecifierSet) -> SpecifierSet:	7✔
189	"""Strip minor versions for some specifiers in the specifier set.
190
191	For background on version specifiers, see PEP 440:
192	https://peps.python.org/pep-0440/#version-specifiers
193	"""
194	specifiers = []	7✔
195	for s in specifier_set:	7✔
196	if not isinstance(s, Specifier):	7✔
NEW 197	return SpecifierSet()	×
198
199	if "*" in str(s):	7✔
200	specifiers.append(s)	7✔
201	elif s.operator in ["~=", "==", ">=", "==="]:	7✔
202	version = Version(s.version)	7✔
203	stripped = Specifier(f"{s.operator}{version.major}.{version.minor}")	7✔
204	specifiers.append(stripped)	7✔
205	elif s.operator == ">":	7✔
206	version = Version(s.version)	7✔
207	if len(version.release) > 2:	7✔
208	s = Specifier(f">={version.major}.{version.minor}")	7✔
209	specifiers.append(s)	7✔
210	else:
211	specifiers.append(s)	7✔
212
213	return SpecifierSet(",".join(str(s) for s in specifiers))	7✔
214
215
216	@lru_cache()	7✔
217	def find_user_pyproject_toml() -> Path:	7✔
218	r"""Return the path to the top-level user configuration for black.
219
220	This looks for ~\.black on Windows and ~/.config/black on Linux and other
221	Unix systems.
222
223	May raise:
224	- RuntimeError: if the current user has no homedir
225	- PermissionError: if the current process cannot access the user's homedir
226	"""
227	if sys.platform == "win32":	7✔
228	# Windows
229	user_config_path = Path.home() / ".black"	×
230	else:
231	config_root = os.environ.get("XDG_CONFIG_HOME", "~/.config")	7✔
232	user_config_path = Path(config_root).expanduser() / "black"	7✔
233	return user_config_path.resolve()	7✔
234
235
236	@lru_cache()	7✔
237	def get_gitignore(root: Path) -> PathSpec:	7✔
238	"""Return a PathSpec matching gitignore content if present."""
239	gitignore = root / ".gitignore"	7✔
240	lines: List[str] = []	7✔
241	if gitignore.is_file():	7✔
242	with gitignore.open(encoding="utf-8") as gf:	7✔
243	lines = gf.readlines()	7✔
244	try:	7✔
245	return PathSpec.from_lines("gitwildmatch", lines)	7✔
246	except GitWildMatchPatternError as e:	7✔
247	err(f"Could not parse {gitignore}: {e}")	7✔
248	raise	7✔
249
250
251	def normalize_path_maybe_ignore(	7✔
252	path: Path,
253	root: Path,
254	report: Optional[Report] = None,
255	) -> Optional[str]:
256	"""Normalize `path`. May return `None` if `path` was ignored.
257
258	`report` is where "path ignored" output goes.
259	"""
260	try:	7✔
261	abspath = path if path.is_absolute() else Path.cwd() / path	7✔
262	normalized_path = abspath.resolve()	7✔
263	try:	7✔
264	root_relative_path = normalized_path.relative_to(root).as_posix()	7✔
265	except ValueError:	7✔
266	if report:	7✔
267	report.path_ignored(	7✔
268	path, f"is a symbolic link that points outside {root}"
269	)
270	return None	7✔
271
272	except OSError as e:	×
273	if report:	×
274	report.path_ignored(path, f"cannot be read because {e}")	×
275	return None	×
276
277	return root_relative_path	7✔
278
279
280	def path_is_ignored(	7✔
281	path: Path, gitignore_dict: Dict[Path, PathSpec], report: Report
282	) -> bool:
283	for gitignore_path, pattern in gitignore_dict.items():	7✔
284	relative_path = normalize_path_maybe_ignore(path, gitignore_path, report)	7✔
285	if relative_path is None:	7✔
286	break	×
287	if pattern.match_file(relative_path):	7✔
288	report.path_ignored(path, "matches a .gitignore file content")	7✔
289	return True	7✔
290	return False	7✔
291
292
293	def path_is_excluded(	7✔
294	normalized_path: str,
295	pattern: Optional[Pattern[str]],
296	) -> bool:
297	match = pattern.search(normalized_path) if pattern else None	7✔
298	return bool(match and match.group(0))	7✔
299
300
301	def gen_python_files(	7✔
302	paths: Iterable[Path],
303	root: Path,
304	include: Pattern[str],
305	exclude: Pattern[str],
306	extend_exclude: Optional[Pattern[str]],
307	force_exclude: Optional[Pattern[str]],
308	report: Report,
309	gitignore_dict: Optional[Dict[Path, PathSpec]],
310	*,
311	verbose: bool,
312	quiet: bool,
313	) -> Iterator[Path]:
314	"""Generate all files under `path` whose paths are not excluded by the
315	`exclude_regex`, `extend_exclude`, or `force_exclude` regexes,
316	but are included by the `include` regex.
317
318	Symbolic links pointing outside of the `root` directory are ignored.
319
320	`report` is where output about exclusions goes.
321	"""
322
323	assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"	7✔
324	for child in paths:	7✔
325	normalized_path = normalize_path_maybe_ignore(child, root, report)	7✔
326	if normalized_path is None:	7✔
327	continue	7✔
328
329	# First ignore files matching .gitignore, if passed
330	if gitignore_dict and path_is_ignored(child, gitignore_dict, report):	7✔
331	continue	7✔
332
333	# Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
334	normalized_path = "/" + normalized_path	7✔
335	if child.is_dir():	7✔
336	normalized_path += "/"	7✔
337
338	if path_is_excluded(normalized_path, exclude):	7✔
339	report.path_ignored(child, "matches the --exclude regular expression")	7✔
340	continue	7✔
341
342	if path_is_excluded(normalized_path, extend_exclude):	7✔
343	report.path_ignored(	7✔
344	child, "matches the --extend-exclude regular expression"
345	)
346	continue	7✔
347
348	if path_is_excluded(normalized_path, force_exclude):	7✔
349	report.path_ignored(child, "matches the --force-exclude regular expression")	×
350	continue	×
351
352	if child.is_dir():	7✔
353	# If gitignore is None, gitignore usage is disabled, while a Falsey
354	# gitignore is when the directory doesn't have a .gitignore file.
355	if gitignore_dict is not None:	7✔
356	new_gitignore_dict = {	7✔
357	**gitignore_dict,
358	root / child: get_gitignore(child),
359	}
360	else:
361	new_gitignore_dict = None	7✔
362	yield from gen_python_files(	7✔
363	child.iterdir(),
364	root,
365	include,
366	exclude,
367	extend_exclude,
368	force_exclude,
369	report,
370	new_gitignore_dict,
371	verbose=verbose,
372	quiet=quiet,
373	)
374
375	elif child.is_file():	7✔
376	if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed(	7✔
377	verbose=verbose, quiet=quiet
378	):
379	continue	7✔
380	include_match = include.search(normalized_path) if include else True	7✔
381	if include_match:	7✔
382	yield child	7✔
383
384
385	def wrap_stream_for_windows(	7✔
386	f: io.TextIOWrapper,
387	) -> Union[io.TextIOWrapper, "colorama.AnsiToWin32"]:
388	"""
389	Wrap stream with colorama's wrap_stream so colors are shown on Windows.
390
391	If `colorama` is unavailable, the original stream is returned unmodified.
392	Otherwise, the `wrap_stream()` function determines whether the stream needs
393	to be wrapped for a Windows environment and will accordingly either return
394	an `AnsiToWin32` wrapper or the original stream.
395	"""
396	try:	7✔
397	from colorama.initialise import wrap_stream	7✔
398	except ImportError:	×
399	return f	×
400	else:
401	# Set `strip=False` to avoid needing to modify test_express_diff_with_color.
402	return wrap_stream(f, convert=None, strip=False, autoreset=False, wrap=True)	7✔

psf / black / 3932668511

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous