Bump RTD Python version from 3.8 to 3.11 (#3868)

[etc/vim.git] / src / black / files.py

diff --git a/src/black/files.py b/src/black/files.py
index ea517f4ece9c2c2bbeaef35d2714ccdf50511992..362898dc0fd71bdc1e19d5c589837c2d0c2a0c96 100644 (file)
--- a/src/black/files.py
+++ b/src/black/files.py
@@ -18,6 +18,8 @@ from typing import (
 )
 
 from mypy_extensions import mypyc_attr
 )
 
 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
 
 from pathspec import PathSpec
 from pathspec.patterns.gitwildmatch import GitWildMatchPatternError
 


@@ -32,6 +34,7 @@ else:
     import tomli as tomllib
 
 from black.handle_ipynb_magics import jupyter_dependencies_are_installed
     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
 
 from black.output import err
 from black.report import Report
 


@@ -39,7 +42,7 @@ if TYPE_CHECKING:
     import colorama  # noqa: F401
 
 
     import colorama  # noqa: F401
 
 

-@lru_cache()
+@lru_cache

 def find_project_root(
     srcs: Sequence[str], stdin_filename: Optional[str] = None
 ) -> Tuple[Path, str]:
 def find_project_root(
     srcs: Sequence[str], stdin_filename: Optional[str] = None
 ) -> Tuple[Path, str]:


@@ -86,9 +89,11 @@ def find_project_root(
     return directory, "file system root"
 
 
     return directory, "file system root"
 
 

-def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
+def find_pyproject_toml(
+    path_search_start: Tuple[str, ...], stdin_filename: Optional[str] = None
+) -> Optional[str]:

     """Find the absolute filepath to a pyproject.toml if it exists"""
     """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, stdin_filename)

     path_pyproject_toml = path_project_root / "pyproject.toml"
     if path_pyproject_toml.is_file():
         return str(path_pyproject_toml)
     path_pyproject_toml = path_project_root / "pyproject.toml"
     if path_pyproject_toml.is_file():
         return str(path_pyproject_toml)


@@ -108,17 +113,106 @@ def find_pyproject_toml(path_search_start: Tuple[str, ...]) -> Optional[str]:
 
 @mypyc_attr(patchable=True)
 def parse_pyproject_toml(path_config: str) -> Dict[str, Any]:
 
 @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
+    """Parse a pyproject toml file, pulling out relevant parts for Black.

 
 

-    If parsing fails, will raise a tomllib.TOMLDecodeError
+    If parsing fails, will raise a tomllib.TOMLDecodeError.

     """
     with open(path_config, "rb") as f:
         pyproject_toml = tomllib.load(f)
     """
     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()}
+    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

 
 

-@lru_cache()
+
+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[str] = 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 "*" 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.
 
 def find_user_pyproject_toml() -> Path:
     r"""Return the path to the top-level user configuration for black.
 


@@ -138,7 +232,7 @@ def find_user_pyproject_toml() -> Path:
     return user_config_path.resolve()
 
 
     return user_config_path.resolve()
 
 

-@lru_cache()
+@lru_cache

 def get_gitignore(root: Path) -> PathSpec:
     """Return a PathSpec matching gitignore content if present."""
     gitignore = root / ".gitignore"
 def get_gitignore(root: Path) -> PathSpec:
     """Return a PathSpec matching gitignore content if present."""
     gitignore = root / ".gitignore"


@@ -182,15 +276,24 @@ def normalize_path_maybe_ignore(
     return root_relative_path
 
 
     return root_relative_path
 
 

-def path_is_ignored(
-    path: Path, gitignore_dict: Dict[Path, PathSpec], report: Report
+def _path_is_ignored(
+    root_relative_path: str,
+    root: Path,
+    gitignore_dict: Dict[Path, PathSpec],
+    report: Report,

 ) -> bool:
 ) -> bool:

+    path = root / root_relative_path
+    # Note that this logic is sensitive to the ordering of gitignore_dict. Callers must
+    # ensure that gitignore_dict is ordered from least specific to most specific.

     for gitignore_path, pattern in gitignore_dict.items():
     for gitignore_path, pattern in gitignore_dict.items():

-        relative_path = normalize_path_maybe_ignore(path, gitignore_path, report)
-        if relative_path is None:
+        try:
+            relative_path = path.relative_to(gitignore_path).as_posix()
+        except ValueError:

             break
         if pattern.match_file(relative_path):
             break
         if pattern.match_file(relative_path):

-            report.path_ignored(path, "matches a .gitignore file content")
+            report.path_ignored(
+                path.relative_to(root), "matches a .gitignore file content"
+            )

             return True
     return False
 
             return True
     return False
 


@@ -227,33 +330,37 @@ def gen_python_files(
 
     assert root.is_absolute(), f"INTERNAL ERROR: `root` must be absolute but is {root}"
     for child in paths:
 
     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
+        root_relative_path = child.absolute().relative_to(root).as_posix()

 
         # First ignore files matching .gitignore, if passed
 
         # First ignore files matching .gitignore, if passed

-        if gitignore_dict and path_is_ignored(child, gitignore_dict, report):
+        if gitignore_dict and _path_is_ignored(
+            root_relative_path, root, gitignore_dict, report
+        ):

             continue
 
         # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.
             continue
 
         # Then ignore with `--exclude` `--extend-exclude` and `--force-exclude` options.

-        normalized_path = "/" + normalized_path
+        root_relative_path = "/" + root_relative_path

         if child.is_dir():
         if child.is_dir():

-            normalized_path += "/"
+            root_relative_path += "/"

 
 

-        if path_is_excluded(normalized_path, exclude):
+        if path_is_excluded(root_relative_path, exclude):

             report.path_ignored(child, "matches the --exclude regular expression")
             continue
 
             report.path_ignored(child, "matches the --exclude regular expression")
             continue
 

-        if path_is_excluded(normalized_path, extend_exclude):
+        if path_is_excluded(root_relative_path, extend_exclude):

             report.path_ignored(
                 child, "matches the --extend-exclude regular expression"
             )
             continue
 
             report.path_ignored(
                 child, "matches the --extend-exclude regular expression"
             )
             continue
 

-        if path_is_excluded(normalized_path, force_exclude):
+        if path_is_excluded(root_relative_path, force_exclude):

             report.path_ignored(child, "matches the --force-exclude regular expression")
             continue
 
             report.path_ignored(child, "matches the --force-exclude regular expression")
             continue
 

+        normalized_path = normalize_path_maybe_ignore(child, root, report)
+        if normalized_path is None:
+            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 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.


@@ -279,7 +386,7 @@ def gen_python_files(
 
         elif child.is_file():
             if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed(
 
         elif child.is_file():
             if child.suffix == ".ipynb" and not jupyter_dependencies_are_installed(

-                verbose=verbose, quiet=quiet
+                warn=verbose or not quiet

             ):
                 continue
             include_match = include.search(normalized_path) if include else True
             ):
                 continue
             include_match = include.search(normalized_path) if include else True