feat: remove global Black imports

src/darker/command_line.py

@@ -5,8 +5,6 @@
 from functools import partial
 from typing import List, Optional, Tuple
 
-from black import TargetVersion
-
 import darkgraylib.command_line
 from darker import help as hlp
 from darker.config import (
@@ -15,6 +13,7 @@
  DarkerConfig,
  OutputMode,
 )
+from darker.configuration.target_version import TargetVersion
 from darker.formatters import get_formatter_names
 from darker.version import __version__
 from darkgraylib.command_line import add_parser_argument

src/darker/configuration/__init__.py

@@ -0,0 +1 @@
+"""Configuration and command line handling."""

src/darker/configuration/target_version.py

@@ -0,0 +1,19 @@
+"""Data structures configuring Darker and formatter plugin behavior."""
+
+from enum import Enum
+
+
+class TargetVersion(Enum):
+ """Python version numbers."""
+
+ PY33 = 3
+ PY34 = 4
+ PY35 = 5
+ PY36 = 6
+ PY37 = 7
+ PY38 = 8
+ PY39 = 9
+ PY310 = 10
+ PY311 = 11
+ PY312 = 12
+ PY313 = 13

src/darker/files.py

@@ -2,18 +2,9 @@
 
 from __future__ import annotations
 
-import inspect
-from typing import TYPE_CHECKING, Collection
-
-from black import (
- DEFAULT_EXCLUDES,
- DEFAULT_INCLUDES,
- Report,
- err,
- find_user_pyproject_toml,
- gen_python_files,
- re_compile_maybe_verbose,
-)
+import re
+from functools import lru_cache
+from typing import TYPE_CHECKING, Collection, Iterable, Iterator, Optional, Pattern
 
 from darkgraylib.files import find_project_root
 
@@ -25,22 +16,112 @@
 
 def find_pyproject_toml(path_search_start: tuple[str, ...]) -> str | None:
  """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)
+ return None
+
+
+DEFAULT_EXCLUDE_RE = re.compile(
+ r"/(\.direnv"
+ r"|\.eggs"
+ r"|\.git"
+ r"|\.hg"
+ r"|\.ipynb_checkpoints"
+ r"|\.mypy_cache"
+ r"|\.nox"
+ r"|\.pytest_cache"
+ r"|\.ruff_cache"
+ r"|\.tox"
+ r"|\.svn"
+ r"|\.venv"
+ r"|\.vscode"
+ r"|__pypackages__"
+ r"|_build"
+ r"|buck-out"
+ r"|build"
+ r"|dist"
+ r"|venv)/"
+)
+DEFAULT_INCLUDE_RE = re.compile(r"(\.pyi?|\.ipynb)$")
+
+
+@lru_cache
+def _cached_resolve(path: Path) -> Path:
+ return path.resolve()
+
 
+def _resolves_outside_root_or_cannot_stat(path: Path, root: Path) -> bool:
+ """Return whether path is a symlink that points outside the root directory.
+
+ Also returns True if we failed to resolve the path.
+
+ This function has been adapted from Black 24.10.0.
+
+ """
  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
+ resolved_path = _cached_resolve(path)
+ except OSError:
+ return True
+ try:
+ resolved_path.relative_to(root)
+ except ValueError:
+ return True
+ return False
+
+
+def _path_is_excluded(
+ normalized_path: str,
+ pattern: Optional[Pattern[str]],
+) -> bool:
+ """Return whether the path is excluded by the pattern.
+
+ This function has been adapted from Black 24.10.0.
+
+ """
+ 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,
+ exclude: Pattern[str],
+ extend_exclude: Optional[Pattern[str]],
+ force_exclude: Optional[Pattern[str]],
+) -> Iterator[Path]:
+ """Generate all files under ``path`` whose paths are not excluded.
+
+ This function has been adapted from Black 24.10.0.
+
+ """
+ assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
+ for child in paths:
+ assert child.is_absolute()
+ root_relative_path = child.relative_to(root).as_posix()
+
+ # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
+ root_relative_path = f"/{root_relative_path}"
+ if child.is_dir():
+ root_relative_path = f"{root_relative_path}/"
+
+ if any(
+ _path_is_excluded(root_relative_path, x)
+ for x in [exclude, extend_exclude, force_exclude]
+ ) or _resolves_outside_root_or_cannot_stat(child, root):
+ continue
+
+ if child.is_dir():
+ yield from _gen_python_files(
+ child.iterdir(), root, exclude, extend_exclude, force_exclude
+ )
+
+ elif child.is_file():
+ include_match = DEFAULT_INCLUDE_RE.search(root_relative_path)
+ if include_match:
+ yield child
 
 
 def filter_python_files(
@@ -58,32 +139,16 @@ def filter_python_files(
  ``black_config``, relative to ``root``.
 
  """
- sig = inspect.signature(gen_python_files)
- # those two exist and are required in black>=21.7b1.dev9
- kwargs = {"verbose": False, "quiet": False} if "verbose" in sig.parameters else {}
- # `gitignore=` was replaced with `gitignore_dict=` in black==22.10.1.dev19+gffaaf48
- for param in sig.parameters:
- if param == "gitignore":
- kwargs[param] = None # type: ignore[assignment]
- elif param == "gitignore_dict":
- kwargs[param] = {} # type: ignore[assignment]
  absolute_paths = {p.resolve() for p in paths}
  directories = {p for p in absolute_paths if p.is_dir()}
  files = {p for p in absolute_paths if p not in directories}
  files_from_directories = set(
- gen_python_files(
+ _gen_python_files(
  directories,
  root,
- include=DEFAULT_INCLUDE_RE,
- exclude=formatter.get_exclude(DEFAULT_EXCLUDE_RE),
- extend_exclude=formatter.get_extend_exclude(),
- force_exclude=formatter.get_force_exclude(),
- report=Report(),
- **kwargs, # type: ignore[arg-type]
+ formatter.get_exclude(DEFAULT_EXCLUDE_RE),
+ formatter.get_extend_exclude(),
+ formatter.get_force_exclude(),
  )
  )
  return {p.resolve().relative_to(root) for p in files_from_directories | files}
-
-
-DEFAULT_EXCLUDE_RE = re_compile_maybe_verbose(DEFAULT_EXCLUDES)
-DEFAULT_INCLUDE_RE = re_compile_maybe_verbose(DEFAULT_INCLUDES)

src/darker/formatters/black_formatter.py

@@ -39,14 +39,6 @@
 import logging
 from typing import TYPE_CHECKING, TypedDict
 
-from black import FileMode as Mode
-from black import (
- TargetVersion,
- format_str,
- parse_pyproject_toml,
- re_compile_maybe_verbose,
-)
-
 from darker.files import find_pyproject_toml
 from darker.formatters.base_formatter import BaseFormatter
 from darkgraylib.config import ConfigurationError
@@ -56,9 +48,11 @@
  from argparse import Namespace
  from typing import Pattern
 
+ from black import FileMode as Mode
+ from black import TargetVersion
+
  from darker.formatters.formatter_config import BlackConfig
 
-__all__ = ["Mode"]
 
 logger = logging.getLogger(__name__)
 
@@ -96,6 +90,9 @@ def read_config(self, src: tuple[str, ...], args: Namespace) -> None:
  self._read_cli_args(args)
 
  def _read_config_file(self, config_path: str) -> None: # noqa: C901
+ # Local import so Darker can be run without Black installed
+ from black import parse_pyproject_toml, re_compile_maybe_verbose
+
  raw_config = parse_pyproject_toml(config_path)
  if "line_length" in raw_config:
  self.config["line_length"] = raw_config["line_length"]
@@ -153,6 +150,9 @@ def run(self, content: TextDocument) -> TextDocument:
  :return: The reformatted content
 
  """
+ # Local import so Darker can be run without Black installed
+ from black import format_str
+
  contents_for_black = content.string_with_newline("\n")
  if contents_for_black.strip():
  dst_contents = format_str(
@@ -173,6 +173,11 @@ def _make_black_options(self) -> Mode:
  # Collect relevant Black configuration options from ``self.config`` in order to
  # pass them to Black's ``format_str()``. File exclusion options aren't needed
  # since at this point we already have a single file's content to work on.
+
+ # Local import so Darker can be run without Black installed
+ from black import FileMode as Mode
+ from black import TargetVersion
+
  mode = BlackModeAttributes()
  if "line_length" in self.config:
  mode["line_length"] = self.config["line_length"]

src/darker/help.py

@@ -2,8 +2,7 @@
 
 from textwrap import dedent
 
-from black import TargetVersion
-
+from darker.configuration.target_version import TargetVersion
 from darker.formatters import get_formatter_names
 
 

src/darker/tests/test_command_line.py

@@ -11,13 +11,12 @@
 
 import pytest
 import toml
-from black import TargetVersion
+from black import FileMode, TargetVersion
 
 import darker.help
 from darker.__main__ import main
 from darker.command_line import make_argument_parser, parse_command_line
 from darker.config import Exclusions
-from darker.formatters import black_formatter
 from darker.formatters.black_formatter import BlackFormatter
 from darker.tests.helpers import flynt_present, isort_present
 from darkgraylib.config import ConfigurationError
@@ -546,9 +545,8 @@ def test_black_options(monkeypatch, tmpdir, git_repo, options, expect):
  {"main.py": 'print("Hello World!")\n'}, commit="Initial commit"
  )
  added_files["main.py"].write_bytes(b'print ("Hello World!")\n')
- with patch.object(
- black_formatter, "Mode", wraps=black_formatter.Mode
- ) as file_mode_class:
+ with patch("black.FileMode", wraps=FileMode) as file_mode_class:
+ # end of test setup, now call the function under test
 
  main(options + [str(path) for path in added_files.values()])
 
@@ -661,11 +659,12 @@ def test_black_config_file_and_options(git_repo, config, options, expect):
  commit="Initial commit",
  )
  added_files["main.py"].write_bytes(b"a = [1, 2,]")
- mode_class_mock = Mock(wraps=black_formatter.Mode)
+ mode_class_mock = Mock(wraps=FileMode)
  # Speed up tests by mocking `format_str` to skip running Black
  format_str = Mock(return_value="a = [1, 2,]")
- with patch.multiple(black_formatter, Mode=mode_class_mock, format_str=format_str):
-
+ with patch("black.FileMode", mode_class_mock), patch(
+ "black.format_str", format_str
+ ):
  main(options + [str(path) for path in added_files.values()])
 
  assert mode_class_mock.call_args_list == [expect]

src/darker/tests/test_files.py

@@ -1,22 +1,33 @@
 """Test for the `darker.files` module."""
 
-import io
-from contextlib import redirect_stderr
 from pathlib import Path
-from unittest.mock import MagicMock, patch
+
+import pytest
 
 from darker import files
 
 
-@patch("darker.files.find_user_pyproject_toml")
-def test_find_pyproject_toml(find_user_pyproject_toml: MagicMock) -> None:
+@pytest.mark.kwparametrize(
+ dict(start="only_pyproject/subdir", expect="only_pyproject/pyproject.toml"),
+ dict(start="only_git/subdir", expect=None),
+ dict(start="git_and_pyproject/subdir", expect="git_and_pyproject/pyproject.toml"),
+)
+def test_find_pyproject_toml(tmp_path: Path, start: str, expect: str) -> None:
  """Test `files.find_pyproject_toml` with no user home directory."""
- find_user_pyproject_toml.side_effect = RuntimeError()
- with redirect_stderr(io.StringIO()) as stderr:
- # end of test setup
+ (tmp_path / "only_pyproject").mkdir()
+ (tmp_path / "only_pyproject" / "pyproject.toml").touch()
+ (tmp_path / "only_pyproject" / "subdir").mkdir()
+ (tmp_path / "only_git").mkdir()
+ (tmp_path / "only_git" / ".git").mkdir()
+ (tmp_path / "only_git" / "subdir").mkdir()
+ (tmp_path / "git_and_pyproject").mkdir()
+ (tmp_path / "git_and_pyproject" / ".git").mkdir()
+ (tmp_path / "git_and_pyproject" / "pyproject.toml").touch()
+ (tmp_path / "git_and_pyproject" / "subdir").mkdir()
 
-  result = files.find_pyproject_toml(path_search_start=(str(Path.cwd().root),))
+ result = files.find_pyproject_toml(path_search_start=(str(tmp_path / start),))
 
- assert result is None
- err = stderr.getvalue()
- assert "Ignoring user configuration" in err
+ if not expect:
+ assert result is None
+ else:
+ assert result == str(tmp_path / expect)