"""Version specifier support using only standard library (PEP 440 compatible)."""

from __future__ import annotations

import contextlib

import operator

import re

import sys

from dataclasses import dataclass

from typing import TYPE_CHECKING, Final

_DC_KW = {"frozen": True, "kw_only": True, "slots": True} if sys.version_info >= (3, 10) else {"frozen": True}

if TYPE_CHECKING:

from collections.abc import Iterator

_VERSION_RE: Final[re.Pattern[str]] = re.compile(

r"""

^

(\d+) # major

(?:\.(\d+))? # optional minor

(?:\.(\d+))? # optional micro

(?:(a|b|rc)(\d+))? # optional pre-release suffix

$

""",

re.VERBOSE,

)

_SPECIFIER_RE: Final[re.Pattern[str]] = re.compile(

r"""

^

(===|==|~=|!=|<=|>=|<|>) # operator

\s*

(.+) # version string

$

""",

re.VERBOSE,

)

_PRE_ORDER: Final[dict[str, int]] = {"a": 1, "b": 2, "rc": 3}

@dataclass(**_DC_KW)

class SimpleVersion:

"""

Simple PEP 440-like version parser using only standard library.

:param version_str: the original version string.

:param major: major version number.

:param minor: minor version number.

:param micro: micro (patch) version number.

:param pre_type: pre-release label (``"a"``, ``"b"``, or ``"rc"``), or ``None``.

:param pre_num: pre-release sequence number, or ``None``.

:param release: the ``(major, minor, micro)`` tuple.

"""

version_str: str

major: int

minor: int

micro: int

pre_type: str | None

pre_num: int | None

release: tuple[int, int, int]

@classmethod

def from_string(cls, version_str: str) -> SimpleVersion:

"""

Parse a PEP 440 version string (e.g. ``3.12.1``).

:param version_str: the version string to parse.

"""

stripped = version_str.strip()

if not (match := _VERSION_RE.match(stripped)):

msg = f"Invalid version: {version_str}"

raise ValueError(msg)

major = int(match.group(1))

minor = int(match.group(2)) if match.group(2) else 0

micro = int(match.group(3)) if match.group(3) else 0

return cls(

version_str=stripped,

major=major,

minor=minor,

micro=micro,

pre_type=match.group(4),

pre_num=int(match.group(5)) if match.group(5) else None,

release=(major, minor, micro),

)

def __eq__(self, other: object) -> bool:

if not isinstance(other, SimpleVersion):

return NotImplemented

return self.release == other.release and self.pre_type == other.pre_type and self.pre_num == other.pre_num

def __hash__(self) -> int:

return hash((self.release, self.pre_type, self.pre_num))

def __lt__(self, other: object) -> bool: # noqa: PLR0911

if not isinstance(other, SimpleVersion):

return NotImplemented

if self.release != other.release:

return self.release < other.release

if self.pre_type is None and other.pre_type is None:

return False

if self.pre_type is None:

return False

if other.pre_type is None:

return True

if _PRE_ORDER[self.pre_type] != _PRE_ORDER[other.pre_type]:

return _PRE_ORDER[self.pre_type] < _PRE_ORDER[other.pre_type]

return (self.pre_num or 0) < (other.pre_num or 0)

def __le__(self, other: object) -> bool:

return self == other or self < other

def __gt__(self, other: object) -> bool:

if not isinstance(other, SimpleVersion):

return NotImplemented

return not self <= other

def __ge__(self, other: object) -> bool:

return not self < other

def __str__(self) -> str:

return self.version_str

def __repr__(self) -> str:

return f"SimpleVersion('{self.version_str}')"

@dataclass(**_DC_KW)

class SimpleSpecifier:

"""

Simple PEP 440-like version specifier using only standard library.

:param spec_str: the original specifier string (e.g. ``>=3.10``).

:param operator: the comparison operator (``==``, ``>=``, ``<``, etc.).

:param version_str: the version portion of the specifier, without the operator.

:param is_wildcard: ``True`` if the specifier uses a wildcard suffix (``.*``).

:param wildcard_precision: number of version components before the wildcard, or ``None``.

:param version: the parsed version, or ``None`` if parsing failed.

"""

spec_str: str

operator: str

version_str: str

is_wildcard: bool

wildcard_precision: int | None

version: SimpleVersion | None

@classmethod

def from_string(cls, spec_str: str) -> SimpleSpecifier:

"""

Parse a single PEP 440 specifier (e.g. ``>=3.10``).

:param spec_str: the specifier string to parse.

"""

stripped = spec_str.strip()

if not (match := _SPECIFIER_RE.match(stripped)):

msg = f"Invalid specifier: {spec_str}"

raise ValueError(msg)

op = match.group(1)

version_str = match.group(2).strip()

is_wildcard = version_str.endswith(".*")

wildcard_precision: int | None = None

if is_wildcard:

version_str = version_str[:-2]

wildcard_precision = len(version_str.split("."))

try:

version = SimpleVersion.from_string(version_str)

except ValueError:

version = None

return cls(

spec_str=stripped,

operator=op,

version_str=version_str,

is_wildcard=is_wildcard,

wildcard_precision=wildcard_precision,

version=version,

)

def contains(self, version_str: str) -> bool:

"""

Check if a version string satisfies this specifier.

:param version_str: the version string to test.

"""

try:

candidate = SimpleVersion.from_string(version_str) if isinstance(version_str, str) else version_str

except ValueError:

return False

if self.version is None:

return False

if self.is_wildcard:

return self._check_wildcard(candidate)

return self._check_standard(candidate)

def _check_wildcard(self, candidate: SimpleVersion) -> bool:

if self.version is None: # pragma: no branch

return False # pragma: no cover

if self.operator == "==":

return candidate.release[: self.wildcard_precision] == self.version.release[: self.wildcard_precision]

if self.operator == "!=":

return candidate.release[: self.wildcard_precision] != self.version.release[: self.wildcard_precision]

return False

def _check_standard(self, candidate: SimpleVersion) -> bool:

if self.version is None: # pragma: no branch

return False # pragma: no cover

if self.operator == "===":

return str(candidate) == str(self.version)

if self.operator == "~=":

return self._check_compatible_release(candidate)

cmp_ops = {

"==": operator.eq,

"!=": operator.ne,

"<": operator.lt,

"<=": operator.le,

">": operator.gt,

">=": operator.ge,

}

if self.operator in cmp_ops:

return cmp_ops[self.operator](candidate, self.version)

return False

def _check_compatible_release(self, candidate: SimpleVersion) -> bool:

if self.version is None:

return False

if candidate < self.version:

return False

if len(self.version.release) >= 2: # noqa: PLR2004 # pragma: no branch # SimpleVersion always has 3-part release

upper_parts = list(self.version.release[:-1])

upper_parts[-1] += 1

upper = SimpleVersion.from_string(".".join(str(p) for p in upper_parts))

return candidate < upper

return True # pragma: no cover

def __eq__(self, other: object) -> bool:

if not isinstance(other, SimpleSpecifier):

return NotImplemented

return self.spec_str == other.spec_str

def __hash__(self) -> int:

return hash(self.spec_str)

def __str__(self) -> str:

return self.spec_str

def __repr__(self) -> str:

return f"SimpleSpecifier('{self.spec_str}')"

@dataclass(**_DC_KW)

class SimpleSpecifierSet:

"""

Simple PEP 440-like specifier set using only standard library.

:param specifiers_str: the original comma-separated specifier string.

:param specifiers: the parsed individual specifiers.

"""

specifiers_str: str

specifiers: tuple[SimpleSpecifier, ...]

@classmethod

def from_string(cls, specifiers_str: str = "") -> SimpleSpecifierSet:

"""

Parse a comma-separated PEP 440 specifier string (e.g. ``>=3.10,<4``).

:param specifiers_str: the specifier string to parse.

"""

stripped = specifiers_str.strip()

specs: list[SimpleSpecifier] = []

if stripped:

for spec_item in stripped.split(","):

item = spec_item.strip()

if item:

with contextlib.suppress(ValueError):

specs.append(SimpleSpecifier.from_string(item))

return cls(specifiers_str=stripped, specifiers=tuple(specs))

def contains(self, version_str: str) -> bool:

"""

Check if a version satisfies all specifiers in the set.

:param version_str: the version string to test.

"""

if not self.specifiers:

return True

return all(spec.contains(version_str) for spec in self.specifiers)

def __iter__(self) -> Iterator[SimpleSpecifier]:

return iter(self.specifiers)

def __eq__(self, other: object) -> bool:

if not isinstance(other, SimpleSpecifierSet):

return NotImplemented

return self.specifiers_str == other.specifiers_str

def __hash__(self) -> int:

return hash(self.specifiers_str)

def __str__(self) -> str:

return self.specifiers_str

def __repr__(self) -> str:

return f"SimpleSpecifierSet('{self.specifiers_str}')"

__all__ = [

"SimpleSpecifier",

"SimpleSpecifierSet",

"SimpleVersion",

]