-from functools import lru_cache
import io
import os
-from pathlib import Path
import sys
+from functools import lru_cache
+from pathlib import Path
from typing import (
+ TYPE_CHECKING,
Any,
Dict,
Iterable,
Sequence,
Tuple,
Union,
- TYPE_CHECKING,
)
+from mypy_extensions import mypyc_attr
from pathspec import PathSpec
-import tomli
+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.output import err
from black.report import Report
@lru_cache()
-def find_project_root(srcs: Sequence[str]) -> Path:
+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
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())]
for directory in (common_base, *common_base.parents):
if (directory / ".git").exists():
- return directory
+ return directory, ".git directory"
if (directory / ".hg").is_dir():
- return directory
+ return directory, ".hg directory"
if (directory / "pyproject.toml").is_file():
- return directory
+ return directory, "pyproject.toml"
- return directory
+ 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_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)
if path_user_pyproject_toml.is_file()
else None
)
- except PermissionError as e:
+ 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 tomli.TOMLDecodeError
+ If parsing fails, will raise a tomllib.TOMLDecodeError
"""
- with open(path_config, encoding="utf8") as f:
- pyproject_toml = tomli.load(f) # type: ignore # due to deprecated API usage
+ with open(path_config, "rb") as f:
+ pyproject_toml = tomllib.load(f)
config = pyproject_toml.get("tool", {}).get("black", {})
return {k.replace("--", "").replace("-", "_"): v for k, v in config.items()}
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
if gitignore.is_file():
with gitignore.open(encoding="utf-8") as gf:
lines = gf.readlines()
- return PathSpec.from_lines("gitwildmatch", lines)
+ 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: Report
+ path: Path,
+ root: Path,
+ report: Optional[Report] = None,
) -> Optional[str]:
"""Normalize `path`. May return `None` if `path` was ignored.
"""
try:
abspath = path if path.is_absolute() else Path.cwd() / path
- normalized_path = abspath.resolve().relative_to(root).as_posix()
- except OSError as e:
- report.path_ignored(path, f"cannot be read because {e}")
- return None
-
- except ValueError:
- if path.is_symlink():
- report.path_ignored(path, f"is a symbolic link that points outside {root}")
+ 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
- raise
+ except OSError as e:
+ if report:
+ report.path_ignored(path, f"cannot be read because {e}")
+ return None
- return normalized_path
+ return root_relative_path
def path_is_excluded(
force_exclude: Optional[Pattern[str]],
report: Report,
gitignore: Optional[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,
force_exclude,
report,
gitignore + get_gitignore(child) if gitignore is not None else None,
+ 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
projects / etc / vim.git / blobdiff