mirror of
https://github.com/pre-commit/pre-commit-hooks.git
synced 2026-04-08 20:44:18 +00:00
[pre-commit.ci] auto fixes from pre-commit.com hooks
for more information, see https://pre-commit.ci
This commit is contained in:
pre-commit-ci[bot]
parent
72ad6dc953
commit
f4cd1ba0d6
813 changed files with 66015 additions and 58839 deletions
|
|
@ -7,17 +7,25 @@
|
|||
from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
|
||||
from packaging.version import Version
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import abc
|
||||
import itertools
|
||||
import re
|
||||
from typing import Callable, Iterable, Iterator, List, Optional, Tuple, TypeVar, Union
|
||||
from typing import Callable
|
||||
from typing import Iterable
|
||||
from typing import Iterator
|
||||
from typing import List
|
||||
from typing import Optional
|
||||
from typing import Tuple
|
||||
from typing import TypeVar
|
||||
from typing import Union
|
||||
|
||||
from .utils import canonicalize_version
|
||||
from .version import Version
|
||||
|
||||
UnparsedVersion = Union[Version, str]
|
||||
UnparsedVersionVar = TypeVar("UnparsedVersionVar", bound=UnparsedVersion)
|
||||
UnparsedVersionVar = TypeVar('UnparsedVersionVar', bound=UnparsedVersion)
|
||||
CallableOperator = Callable[[Version, str], bool]
|
||||
|
||||
|
||||
|
|
@ -64,7 +72,7 @@ class BaseSpecifier(metaclass=abc.ABCMeta):
|
|||
|
||||
@property
|
||||
@abc.abstractmethod
|
||||
def prereleases(self) -> Optional[bool]:
|
||||
def prereleases(self) -> bool | None:
|
||||
"""Whether or not pre-releases as a whole are allowed.
|
||||
|
||||
This can be set to either ``True`` or ``False`` to explicitly enable or disable
|
||||
|
|
@ -79,14 +87,14 @@ class BaseSpecifier(metaclass=abc.ABCMeta):
|
|||
"""
|
||||
|
||||
@abc.abstractmethod
|
||||
def contains(self, item: str, prereleases: Optional[bool] = None) -> bool:
|
||||
def contains(self, item: str, prereleases: bool | None = None) -> bool:
|
||||
"""
|
||||
Determines if the given item is contained within this specifier.
|
||||
"""
|
||||
|
||||
@abc.abstractmethod
|
||||
def filter(
|
||||
self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None
|
||||
self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None,
|
||||
) -> Iterator[UnparsedVersionVar]:
|
||||
"""
|
||||
Takes an iterable of items and filters them so that only items which
|
||||
|
|
@ -202,22 +210,22 @@ class Specifier(BaseSpecifier):
|
|||
"""
|
||||
|
||||
_regex = re.compile(
|
||||
r"^\s*" + _operator_regex_str + _version_regex_str + r"\s*$",
|
||||
r'^\s*' + _operator_regex_str + _version_regex_str + r'\s*$',
|
||||
re.VERBOSE | re.IGNORECASE,
|
||||
)
|
||||
|
||||
_operators = {
|
||||
"~=": "compatible",
|
||||
"==": "equal",
|
||||
"!=": "not_equal",
|
||||
"<=": "less_than_equal",
|
||||
">=": "greater_than_equal",
|
||||
"<": "less_than",
|
||||
">": "greater_than",
|
||||
"===": "arbitrary",
|
||||
'~=': 'compatible',
|
||||
'==': 'equal',
|
||||
'!=': 'not_equal',
|
||||
'<=': 'less_than_equal',
|
||||
'>=': 'greater_than_equal',
|
||||
'<': 'less_than',
|
||||
'>': 'greater_than',
|
||||
'===': 'arbitrary',
|
||||
}
|
||||
|
||||
def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
|
||||
def __init__(self, spec: str = '', prereleases: bool | None = None) -> None:
|
||||
"""Initialize a Specifier instance.
|
||||
|
||||
:param spec:
|
||||
|
|
@ -234,9 +242,9 @@ class Specifier(BaseSpecifier):
|
|||
if not match:
|
||||
raise InvalidSpecifier(f"Invalid specifier: '{spec}'")
|
||||
|
||||
self._spec: Tuple[str, str] = (
|
||||
match.group("operator").strip(),
|
||||
match.group("version").strip(),
|
||||
self._spec: tuple[str, str] = (
|
||||
match.group('operator').strip(),
|
||||
match.group('version').strip(),
|
||||
)
|
||||
|
||||
# Store whether or not this Specifier should accept prereleases
|
||||
|
|
@ -254,10 +262,10 @@ class Specifier(BaseSpecifier):
|
|||
# operators, and if they are if they are including an explicit
|
||||
# prerelease.
|
||||
operator, version = self._spec
|
||||
if operator in ["==", ">=", "<=", "~=", "==="]:
|
||||
if operator in ['==', '>=', '<=', '~=', '===']:
|
||||
# The == specifier can include a trailing .*, if it does we
|
||||
# want to remove before parsing.
|
||||
if operator == "==" and version.endswith(".*"):
|
||||
if operator == '==' and version.endswith('.*'):
|
||||
version = version[:-2]
|
||||
|
||||
# Parse the version, and if it is a pre-release than this
|
||||
|
|
@ -300,12 +308,12 @@ class Specifier(BaseSpecifier):
|
|||
<Specifier('>=1.0.0', prereleases=True)>
|
||||
"""
|
||||
pre = (
|
||||
f", prereleases={self.prereleases!r}"
|
||||
f', prereleases={self.prereleases!r}'
|
||||
if self._prereleases is not None
|
||||
else ""
|
||||
else ''
|
||||
)
|
||||
|
||||
return f"<{self.__class__.__name__}({str(self)!r}{pre})>"
|
||||
return f'<{self.__class__.__name__}({str(self)!r}{pre})>'
|
||||
|
||||
def __str__(self) -> str:
|
||||
"""A string representation of the Specifier that can be round-tripped.
|
||||
|
|
@ -315,13 +323,13 @@ class Specifier(BaseSpecifier):
|
|||
>>> str(Specifier('>=1.0.0', prereleases=False))
|
||||
'>=1.0.0'
|
||||
"""
|
||||
return "{}{}".format(*self._spec)
|
||||
return '{}{}'.format(*self._spec)
|
||||
|
||||
@property
|
||||
def _canonical_spec(self) -> Tuple[str, str]:
|
||||
def _canonical_spec(self) -> tuple[str, str]:
|
||||
canonical_version = canonicalize_version(
|
||||
self._spec[1],
|
||||
strip_trailing_zero=(self._spec[0] != "~="),
|
||||
strip_trailing_zero=(self._spec[0] != '~='),
|
||||
)
|
||||
return self._spec[0], canonical_version
|
||||
|
||||
|
|
@ -359,7 +367,7 @@ class Specifier(BaseSpecifier):
|
|||
|
||||
def _get_operator(self, op: str) -> CallableOperator:
|
||||
operator_callable: CallableOperator = getattr(
|
||||
self, f"_compare_{self._operators[op]}"
|
||||
self, f'_compare_{self._operators[op]}',
|
||||
)
|
||||
return operator_callable
|
||||
|
||||
|
|
@ -374,23 +382,23 @@ class Specifier(BaseSpecifier):
|
|||
# We want everything but the last item in the version, but we want to
|
||||
# ignore suffix segments.
|
||||
prefix = _version_join(
|
||||
list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1]
|
||||
list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1],
|
||||
)
|
||||
|
||||
# Add the prefix notation to the end of our string
|
||||
prefix += ".*"
|
||||
prefix += '.*'
|
||||
|
||||
return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
|
||||
prospective, prefix
|
||||
return self._get_operator('>=')(prospective, spec) and self._get_operator('==')(
|
||||
prospective, prefix,
|
||||
)
|
||||
|
||||
def _compare_equal(self, prospective: Version, spec: str) -> bool:
|
||||
|
||||
# We need special logic to handle prefix matching
|
||||
if spec.endswith(".*"):
|
||||
if spec.endswith('.*'):
|
||||
# In the case of prefix matching we want to ignore local segment.
|
||||
normalized_prospective = canonicalize_version(
|
||||
prospective.public, strip_trailing_zero=False
|
||||
prospective.public, strip_trailing_zero=False,
|
||||
)
|
||||
# Get the normalized version string ignoring the trailing .*
|
||||
normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False)
|
||||
|
|
@ -501,7 +509,7 @@ class Specifier(BaseSpecifier):
|
|||
def _compare_arbitrary(self, prospective: Version, spec: str) -> bool:
|
||||
return str(prospective).lower() == str(spec).lower()
|
||||
|
||||
def __contains__(self, item: Union[str, Version]) -> bool:
|
||||
def __contains__(self, item: str | Version) -> bool:
|
||||
"""Return whether or not the item is contained in this specifier.
|
||||
|
||||
:param item: The item to check for.
|
||||
|
|
@ -523,7 +531,7 @@ class Specifier(BaseSpecifier):
|
|||
return self.contains(item)
|
||||
|
||||
def contains(
|
||||
self, item: UnparsedVersion, prereleases: Optional[bool] = None
|
||||
self, item: UnparsedVersion, prereleases: bool | None = None,
|
||||
) -> bool:
|
||||
"""Return whether or not the item is contained in this specifier.
|
||||
|
||||
|
|
@ -569,7 +577,7 @@ class Specifier(BaseSpecifier):
|
|||
return operator_callable(normalized_item, self.version)
|
||||
|
||||
def filter(
|
||||
self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None
|
||||
self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None,
|
||||
) -> Iterator[UnparsedVersionVar]:
|
||||
"""Filter items in the given iterable, that match the specifier.
|
||||
|
||||
|
|
@ -601,7 +609,7 @@ class Specifier(BaseSpecifier):
|
|||
yielded = False
|
||||
found_prereleases = []
|
||||
|
||||
kw = {"prereleases": prereleases if prereleases is not None else True}
|
||||
kw = {'prereleases': prereleases if prereleases is not None else True}
|
||||
|
||||
# Attempt to iterate over all the values in the iterable and if any of
|
||||
# them match, yield them.
|
||||
|
|
@ -630,10 +638,10 @@ class Specifier(BaseSpecifier):
|
|||
yield version
|
||||
|
||||
|
||||
_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")
|
||||
_prefix_regex = re.compile(r'^([0-9]+)((?:a|b|c|rc)[0-9]+)$')
|
||||
|
||||
|
||||
def _version_split(version: str) -> List[str]:
|
||||
def _version_split(version: str) -> list[str]:
|
||||
"""Split version into components.
|
||||
|
||||
The split components are intended for version comparison. The logic does
|
||||
|
|
@ -641,12 +649,12 @@ def _version_split(version: str) -> List[str]:
|
|||
components back with :func:`_version_join` may not produce the original
|
||||
version string.
|
||||
"""
|
||||
result: List[str] = []
|
||||
result: list[str] = []
|
||||
|
||||
epoch, _, rest = version.rpartition("!")
|
||||
result.append(epoch or "0")
|
||||
epoch, _, rest = version.rpartition('!')
|
||||
result.append(epoch or '0')
|
||||
|
||||
for item in rest.split("."):
|
||||
for item in rest.split('.'):
|
||||
match = _prefix_regex.search(item)
|
||||
if match:
|
||||
result.extend(match.groups())
|
||||
|
|
@ -655,7 +663,7 @@ def _version_split(version: str) -> List[str]:
|
|||
return result
|
||||
|
||||
|
||||
def _version_join(components: List[str]) -> str:
|
||||
def _version_join(components: list[str]) -> str:
|
||||
"""Join split version components into a version string.
|
||||
|
||||
This function assumes the input came from :func:`_version_split`, where the
|
||||
|
|
@ -668,11 +676,11 @@ def _version_join(components: List[str]) -> str:
|
|||
|
||||
def _is_not_suffix(segment: str) -> bool:
|
||||
return not any(
|
||||
segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post")
|
||||
segment.startswith(prefix) for prefix in ('dev', 'a', 'b', 'rc', 'post')
|
||||
)
|
||||
|
||||
|
||||
def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]:
|
||||
def _pad_version(left: list[str], right: list[str]) -> tuple[list[str], list[str]]:
|
||||
left_split, right_split = [], []
|
||||
|
||||
# Get the release segment of our versions
|
||||
|
|
@ -680,12 +688,12 @@ def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str
|
|||
right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))
|
||||
|
||||
# Get the rest of our versions
|
||||
left_split.append(left[len(left_split[0]) :])
|
||||
right_split.append(right[len(right_split[0]) :])
|
||||
left_split.append(left[len(left_split[0]):])
|
||||
right_split.append(right[len(right_split[0]):])
|
||||
|
||||
# Insert our padding
|
||||
left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
|
||||
right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))
|
||||
left_split.insert(1, ['0'] * max(0, len(right_split[0]) - len(left_split[0])))
|
||||
right_split.insert(1, ['0'] * max(0, len(left_split[0]) - len(right_split[0])))
|
||||
|
||||
return (
|
||||
list(itertools.chain.from_iterable(left_split)),
|
||||
|
|
@ -701,7 +709,7 @@ class SpecifierSet(BaseSpecifier):
|
|||
"""
|
||||
|
||||
def __init__(
|
||||
self, specifiers: str = "", prereleases: Optional[bool] = None
|
||||
self, specifiers: str = '', prereleases: bool | None = None,
|
||||
) -> None:
|
||||
"""Initialize a SpecifierSet instance.
|
||||
|
||||
|
|
@ -720,7 +728,7 @@ class SpecifierSet(BaseSpecifier):
|
|||
|
||||
# Split on `,` to break each individual specifier into it's own item, and
|
||||
# strip each item to remove leading/trailing whitespace.
|
||||
split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]
|
||||
split_specifiers = [s.strip() for s in specifiers.split(',') if s.strip()]
|
||||
|
||||
# Make each individual specifier a Specifier and save in a frozen set for later.
|
||||
self._specs = frozenset(map(Specifier, split_specifiers))
|
||||
|
|
@ -730,7 +738,7 @@ class SpecifierSet(BaseSpecifier):
|
|||
self._prereleases = prereleases
|
||||
|
||||
@property
|
||||
def prereleases(self) -> Optional[bool]:
|
||||
def prereleases(self) -> bool | None:
|
||||
# If we have been given an explicit prerelease modifier, then we'll
|
||||
# pass that through here.
|
||||
if self._prereleases is not None:
|
||||
|
|
@ -764,12 +772,12 @@ class SpecifierSet(BaseSpecifier):
|
|||
<SpecifierSet('!=2.0.0,>=1.0.0', prereleases=True)>
|
||||
"""
|
||||
pre = (
|
||||
f", prereleases={self.prereleases!r}"
|
||||
f', prereleases={self.prereleases!r}'
|
||||
if self._prereleases is not None
|
||||
else ""
|
||||
else ''
|
||||
)
|
||||
|
||||
return f"<SpecifierSet({str(self)!r}{pre})>"
|
||||
return f'<SpecifierSet({str(self)!r}{pre})>'
|
||||
|
||||
def __str__(self) -> str:
|
||||
"""A string representation of the specifier set that can be round-tripped.
|
||||
|
|
@ -782,12 +790,12 @@ class SpecifierSet(BaseSpecifier):
|
|||
>>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False))
|
||||
'!=1.0.1,>=1.0.0'
|
||||
"""
|
||||
return ",".join(sorted(str(s) for s in self._specs))
|
||||
return ','.join(sorted(str(s) for s in self._specs))
|
||||
|
||||
def __hash__(self) -> int:
|
||||
return hash(self._specs)
|
||||
|
||||
def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet":
|
||||
def __and__(self, other: SpecifierSet | str) -> SpecifierSet:
|
||||
"""Return a SpecifierSet which is a combination of the two sets.
|
||||
|
||||
:param other: The other object to combine with.
|
||||
|
|
@ -813,8 +821,8 @@ class SpecifierSet(BaseSpecifier):
|
|||
specifier._prereleases = self._prereleases
|
||||
else:
|
||||
raise ValueError(
|
||||
"Cannot combine SpecifierSets with True and False prerelease "
|
||||
"overrides."
|
||||
'Cannot combine SpecifierSets with True and False prerelease '
|
||||
'overrides.',
|
||||
)
|
||||
|
||||
return specifier
|
||||
|
|
@ -883,8 +891,8 @@ class SpecifierSet(BaseSpecifier):
|
|||
def contains(
|
||||
self,
|
||||
item: UnparsedVersion,
|
||||
prereleases: Optional[bool] = None,
|
||||
installed: Optional[bool] = None,
|
||||
prereleases: bool | None = None,
|
||||
installed: bool | None = None,
|
||||
) -> bool:
|
||||
"""Return whether or not the item is contained in this SpecifierSet.
|
||||
|
||||
|
|
@ -938,7 +946,7 @@ class SpecifierSet(BaseSpecifier):
|
|||
return all(s.contains(item, prereleases=prereleases) for s in self._specs)
|
||||
|
||||
def filter(
|
||||
self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None
|
||||
self, iterable: Iterable[UnparsedVersionVar], prereleases: bool | None = None,
|
||||
) -> Iterator[UnparsedVersionVar]:
|
||||
"""Filter items in the given iterable, that match the specifiers in this set.
|
||||
|
||||
|
|
@ -995,8 +1003,8 @@ class SpecifierSet(BaseSpecifier):
|
|||
# which will filter out any pre-releases, unless there are no final
|
||||
# releases.
|
||||
else:
|
||||
filtered: List[UnparsedVersionVar] = []
|
||||
found_prereleases: List[UnparsedVersionVar] = []
|
||||
filtered: list[UnparsedVersionVar] = []
|
||||
found_prereleases: list[UnparsedVersionVar] = []
|
||||
|
||||
for item in iterable:
|
||||
parsed_version = _coerce_version(item)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue