Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.10/site-packages/packaging/_ranges.py: 23%
Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# This file is dual licensed under the terms of the Apache License, Version
2# 2.0, and the BSD License. See the LICENSE file in the root of this repository
3# for complete details.
4"""Private version-range helpers used by :mod:`packaging.specifiers`."""
6from __future__ import annotations
8import enum
9import functools
10from typing import (
11 TYPE_CHECKING,
12 Any,
13 Final,
14)
16from .version import InvalidVersion, Version
18if TYPE_CHECKING:
19 from collections.abc import Callable, Iterable, Iterator, Sequence
21 # Total-order key for comparing two boundaries (boundary-vs-boundary only).
22 # The post slot may be ``_BOUNDARY_INF`` for an AFTER_POSTS boundary.
23 _BoundaryOrderSuffix = tuple[int, int, int, int | float, int, int]
24 _BoundaryOrderKey = tuple[int, tuple[int, ...], _BoundaryOrderSuffix, float]
26__all__ = [
27 "FULL_RANGE",
28 "bounds_for_spec",
29 "coerce_version",
30 "filter_by_ranges",
31 "intersect_ranges",
32 "intersect_specifier_bounds",
33 "least_version_above",
34 "matches_bounds_only",
35 "range_is_empty",
36 "ranges_are_prerelease_only",
37 "resolve_prereleases",
38 "standard_ranges",
39 "wildcard_ranges",
40]
42#: The smallest possible PEP 440 version. No valid version is less than this.
43MIN_VERSION: Final[Version] = Version("0.dev0")
45#: The smallest non-pre-release version, i.e. the nearest non-pre-release at or
46#: above the ``-inf`` floor.
47MIN_RELEASE: Final[Version] = Version("0")
49#: Sorts above any real post number and any local label, so a boundary can be
50#: ordered above the version family it covers when two boundaries are compared.
51_BOUNDARY_INF: Final[float] = float("inf")
54class BoundaryKind(enum.Enum):
55 """Where a boundary marker sits in the version ordering."""
57 AFTER_LOCALS = enum.auto() # after V+local, before V.post0
58 AFTER_POSTS = enum.auto() # after V.postN, before next release
61@functools.total_ordering
62class BoundaryVersion:
63 """A point on the version line between two real PEP 440 versions.
65 Relative to a base version V::
67 V < V+local < AFTER_LOCALS(V) < V.post0 < AFTER_POSTS(V)
69 AFTER_LOCALS is the upper bound of ``<=V``, ``==V``, ``!=V`` (no
70 local), and the lower bound of the upper-side range of ``!=V``.
71 AFTER_POSTS is the lower bound of ``>V`` (V final or pre-release),
72 excluding V's post-releases per PEP 440.
73 """
75 __slots__ = (
76 "_cached_dev",
77 "_cached_epoch",
78 "_cached_post",
79 "_cached_pre",
80 "_cached_trimmed_release",
81 "kind",
82 "version",
83 )
85 def __init__(self, version: Version, kind: BoundaryKind) -> None:
86 self.version = version
87 self.kind = kind
88 self._cached_trimmed_release = trim_release(version.release)
89 self._cached_epoch = version.epoch
90 self._cached_pre = version.pre
91 self._cached_post = version.post
92 self._cached_dev = version.dev
94 def _is_family(self, other: Version) -> bool:
95 """Is ``other`` a version that this boundary sorts above?"""
96 if other.epoch != self._cached_epoch:
97 return False
98 # Inline release-trim comparison: other.release matches the
99 # trimmed release iff its leading slice is equal and any extra
100 # components are zero. Avoids trim_release's tuple allocation.
101 other_release = other.release
102 trimmed_release = self._cached_trimmed_release
103 trimmed_length = len(trimmed_release)
104 if len(other_release) < trimmed_length:
105 return False
106 if other_release[:trimmed_length] != trimmed_release:
107 return False
108 for i in range(trimmed_length, len(other_release)):
109 if other_release[i] != 0:
110 return False
111 if other.pre != self._cached_pre:
112 return False
113 if self.kind == BoundaryKind.AFTER_LOCALS:
114 # Local family: same public version, any local label.
115 return other.post == self._cached_post and other.dev == self._cached_dev
116 # Post family: V itself + any post-release of V.
117 return other.dev == self._cached_dev or other.post is not None
119 def _order_key(self) -> _BoundaryOrderKey:
120 """Sort key placing this boundary just above the versions it covers.
122 It extends ``V``'s comparison key ``(epoch, release, suffix)`` with
123 a trailing ``_BOUNDARY_INF`` local component, so the key sorts after
124 ``V`` and every ``V+local`` (whose keys carry a real, finite local
125 segment). ``suffix`` is the 6-int comparison suffix
126 ``(pre_rank, pre_n, post_rank, post_n, dev_rank, dev_n)``.
128 For an AFTER_POSTS boundary the suffix is replaced with one whose
129 post number is ``_BOUNDARY_INF``, so the key also sorts after every
130 ``V.postN``. An AFTER_LOCALS boundary uses ``V``'s suffix unchanged.
131 """
132 version_key = self.version._key
133 suffix: _BoundaryOrderSuffix = version_key[2]
135 if self.kind == BoundaryKind.AFTER_POSTS:
136 suffix = (suffix[0], suffix[1], 1, _BOUNDARY_INF, 1, 0)
138 return version_key[0], version_key[1], suffix, _BOUNDARY_INF
140 def __eq__(self, other: object) -> bool:
141 # Key off the order key so equality matches the ``<`` / ``>`` order:
142 # ``AFTER_POSTS(1.0)`` and ``AFTER_POSTS(1.0.post1)`` are the same point.
143 if isinstance(other, BoundaryVersion):
144 return self._order_key() == other._order_key()
145 return NotImplemented
147 def __lt__(self, other: BoundaryVersion | Version) -> bool:
148 if isinstance(other, BoundaryVersion):
149 return self._order_key() < other._order_key()
150 # boundary < other_version iff V < other AND other not in family.
151 # The cheap V >= other path short-circuits before the family check.
152 if not (self.version < other):
153 return False
154 return not self._is_family(other)
156 def __gt__(self, other: BoundaryVersion | Version) -> bool:
157 # Defined directly to bypass functools.total_ordering's
158 # NotImplemented round-trip on reflected ``Version < boundary``.
159 if isinstance(other, BoundaryVersion):
160 return self._order_key() > other._order_key()
161 if self.version >= other:
162 return True
163 return self._is_family(other)
165 def __hash__(self) -> int:
166 # Keyed to ``__eq__`` (the order key), so equal boundaries hash equal.
167 return hash(self._order_key())
169 def __repr__(self) -> str:
170 return f"{self.__class__.__name__}({self.version!r}, {self.kind.name})"
173if TYPE_CHECKING:
174 _VersionOrBoundary = Version | BoundaryVersion | None
177@functools.total_ordering
178class LowerBound:
179 """Lower bound of a version range.
181 A version *v* of ``None`` means unbounded below (-inf).
182 At equal versions, ``[v`` sorts before ``(v`` because an inclusive
183 bound starts earlier.
184 """
186 __slots__ = ("_above", "inclusive", "version")
188 def __init__(self, version: _VersionOrBoundary, inclusive: bool) -> None:
189 self.version = version
190 self.inclusive = inclusive
191 # Pre-bind a predicate "is parsed at or above this lower
192 # bound?" for the hot filter / contains loops. One direct
193 # call per check, no operator-dispatch chain.
194 if version is None:
195 self._above: Callable[[Version], bool] | None = None
196 elif isinstance(version, BoundaryVersion):
197 # >V produces an AFTER_POSTS lower bound; the upper-side
198 # range of !=V produces an AFTER_LOCALS lower bound.
199 if version.kind == BoundaryKind.AFTER_POSTS:
200 self._above = _make_above_after_posts(version.version)
201 else:
202 self._above = _make_above_after_locals(version.version)
203 elif inclusive:
204 self._above = version.__le__
205 else:
206 self._above = version.__lt__
208 def __eq__(self, other: object) -> bool:
209 if not isinstance(other, LowerBound):
210 return NotImplemented
211 return self.version == other.version and self.inclusive == other.inclusive
213 def __lt__(self, other: LowerBound) -> bool:
214 if not isinstance(other, LowerBound):
215 return NotImplemented
216 # -inf < anything (except -inf itself).
217 if self.version is None:
218 return other.version is not None
219 if other.version is None:
220 return False
221 if self.version != other.version:
222 return self.version < other.version
223 # [v < (v: inclusive starts earlier.
224 return self.inclusive and not other.inclusive
226 def __hash__(self) -> int:
227 return hash((self.version, self.inclusive))
229 def __repr__(self) -> str:
230 bracket = "[" if self.inclusive else "("
231 return f"<{self.__class__.__name__} {bracket}{self.version!r}>"
234@functools.total_ordering
235class UpperBound:
236 """Upper bound of a version range.
238 A version *v* of ``None`` means unbounded above (+inf).
239 At equal versions, ``v)`` sorts before ``v]`` because an exclusive
240 bound ends earlier.
241 """
243 __slots__ = ("_below", "inclusive", "version")
245 def __init__(self, version: _VersionOrBoundary, inclusive: bool) -> None:
246 self.version = version
247 self.inclusive = inclusive
248 # Pre-bind a predicate "is parsed at or below this upper
249 # bound?". See LowerBound for the rationale.
250 if version is None:
251 self._below: Callable[[Version], bool] | None = None
252 elif isinstance(version, BoundaryVersion):
253 # Standard specifiers only ever produce AFTER_LOCALS upper
254 # bounds (from <=V / ==V / !=V with no local).
255 if version.kind == BoundaryKind.AFTER_LOCALS:
256 self._below = _make_below_after_locals(version.version)
257 else:
258 # An AFTER_POSTS upper is not produced by any specifier, but
259 # range algebra reaches it: complementing ``>V`` flips the
260 # ``AFTER_POSTS(V)`` lower into this upper bound.
261 self._below = version.__ge__
262 elif inclusive:
263 self._below = version.__ge__
264 else:
265 self._below = version.__gt__
267 def __eq__(self, other: object) -> bool:
268 if not isinstance(other, UpperBound):
269 return NotImplemented
270 return self.version == other.version and self.inclusive == other.inclusive
272 def __lt__(self, other: UpperBound) -> bool:
273 if not isinstance(other, UpperBound):
274 return NotImplemented
275 # Nothing < +inf (except +inf itself).
276 if self.version is None:
277 return False
278 if other.version is None:
279 return True
280 if self.version != other.version:
281 return self.version < other.version
282 # v) < v]: exclusive ends earlier.
283 return not self.inclusive and other.inclusive
285 def __hash__(self) -> int:
286 return hash((self.version, self.inclusive))
288 def __repr__(self) -> str:
289 bracket = "]" if self.inclusive else ")"
290 return f"<{self.__class__.__name__} {self.version!r}{bracket}>"
293if TYPE_CHECKING:
294 #: A single contiguous interval as a (lower, upper) bound pair.
295 Interval = tuple[LowerBound, UpperBound]
298NEG_INF: Final[LowerBound] = LowerBound(None, False)
299POS_INF: Final[UpperBound] = UpperBound(None, False)
300FULL_RANGE: Final[tuple[Interval]] = ((NEG_INF, POS_INF),)
303def trim_release(release: tuple[int, ...]) -> tuple[int, ...]:
304 """Strip trailing zeros from a release tuple for normalized comparison."""
305 end = len(release)
306 while end > 1 and release[end - 1] == 0:
307 end -= 1
308 return release if end == len(release) else release[:end]
311def _next_prefix_dev0(version: Version) -> Version:
312 """Smallest version in the next prefix: 1.2 -> 1.3.dev0."""
313 release = (*version.release[:-1], version.release[-1] + 1)
314 return Version.from_parts(epoch=version.epoch, release=release, dev=0)
317def _base_dev0(version: Version) -> Version:
318 """The .dev0 of a version's base release: 1.2 -> 1.2.dev0."""
319 return Version.from_parts(epoch=version.epoch, release=version.release, dev=0)
322def coerce_version(version: Version | str) -> Version | None:
323 if not isinstance(version, Version):
324 try:
325 version = Version(version)
326 except InvalidVersion:
327 return None
328 return version
331def _make_above_after_posts(version: Version) -> Callable[[Version], bool]:
332 """Predicate ``parsed > AFTER_POSTS(V)`` for a lower bound.
334 Per PEP 440, ``>V`` excludes V's post-releases unless V is itself
335 a post-release. AFTER_POSTS sits above V and every V.postN (with
336 or without local), and just below the next release.
337 """
338 version_ge = version.__ge__
339 version_epoch = version.epoch
340 version_pre = version.pre
341 version_release_trimmed = trim_release(version.release)
342 trimmed_length = len(version_release_trimmed)
344 def above(parsed: Version) -> bool:
345 if version_ge(parsed):
346 return False
347 # parsed > V cmpkey-wise: above the boundary iff NOT in V's
348 # post family.
349 if parsed.epoch != version_epoch:
350 return True
351 parsed_release = parsed.release
352 if len(parsed_release) < trimmed_length:
353 return True
354 if parsed_release[:trimmed_length] != version_release_trimmed:
355 return True
356 for i in range(trimmed_length, len(parsed_release)):
357 if parsed_release[i] != 0:
358 return True
359 if parsed.pre != version_pre:
360 return True
362 # Same release and pre as V: parsed is in V's post family (V itself,
363 # V+local, or V.postN), which the boundary sits above. A V.devN
364 # (different dev, no post) sorts before V and was already caught by
365 # ``version_ge`` above, so the answer here is always "not above".
366 return False
368 return above
371def _make_above_after_locals(version: Version) -> Callable[[Version], bool]:
372 """Predicate ``parsed > AFTER_LOCALS(V)`` for a lower bound.
374 Used by the upper-side range of ``!=V`` (when V has no local
375 segment). AFTER_LOCALS sits above V and every ``V+local`` but
376 just below ``V.post0``.
377 """
378 version_ge = version.__ge__
379 version_epoch = version.epoch
380 version_pre = version.pre
381 version_post = version.post
382 version_dev = version.dev
383 version_release_trimmed = trim_release(version.release)
384 trimmed_length = len(version_release_trimmed)
386 def above(parsed: Version) -> bool:
387 if version_ge(parsed):
388 return False
389 # parsed > V cmpkey-wise: above the boundary iff NOT in V's
390 # local family (same public version, any local segment).
391 if parsed.epoch != version_epoch:
392 return True
393 parsed_release = parsed.release
394 if len(parsed_release) < trimmed_length:
395 return True
396 if parsed_release[:trimmed_length] != version_release_trimmed:
397 return True
398 for i in range(trimmed_length, len(parsed_release)):
399 if parsed_release[i] != 0:
400 return True
401 if parsed.pre != version_pre:
402 return True
403 if parsed.post != version_post:
404 return True
405 return parsed.dev != version_dev
407 return above
410def _make_below_after_locals(version: Version) -> Callable[[Version], bool]:
411 """Predicate ``parsed <= AFTER_LOCALS(V)`` for an upper bound.
413 Used by ``<=V``, ``==V``, ``!=V`` (no local). ``parsed`` is at or
414 below the boundary when it is at or below V cmpkey-wise, or when
415 it is in V's local family.
416 """
417 version_ge = version.__ge__
418 version_epoch = version.epoch
419 version_pre = version.pre
420 version_post = version.post
421 version_dev = version.dev
422 version_release_trimmed = trim_release(version.release)
423 trimmed_length = len(version_release_trimmed)
425 def below(parsed: Version) -> bool:
426 if version_ge(parsed):
427 return True
428 # parsed > V cmpkey-wise: below the boundary iff in V's local
429 # family.
430 if parsed.epoch != version_epoch:
431 return False
432 parsed_release = parsed.release
433 if len(parsed_release) < trimmed_length:
434 return False
435 if parsed_release[:trimmed_length] != version_release_trimmed:
436 return False
437 for i in range(trimmed_length, len(parsed_release)):
438 if parsed_release[i] != 0:
439 return False
440 if parsed.pre != version_pre:
441 return False
442 if parsed.post != version_post:
443 return False
444 return parsed.dev == version_dev
446 return below
449def least_version_above(boundary: BoundaryVersion) -> Version | None:
450 """Smallest real version strictly above *boundary*, or ``None`` if none exists."""
451 base = boundary.version
453 if boundary.kind == BoundaryKind.AFTER_LOCALS:
454 # AFTER_LOCALS(V) sits just below V.post0, so its least successor is
455 # V.post0.dev0 (V.dev(N+1) if V has a dev, V.post(N+1).dev0 if a post).
456 if base.dev is not None:
457 return base.__replace__(dev=base.dev + 1, local=None)
458 next_post = (base.post + 1) if base.post is not None else 0
459 return base.__replace__(post=next_post, dev=0, local=None)
461 # AFTER_POSTS(V): a pre-release V steps to the next pre-release's .dev0;
462 # a final-release AFTER_POSTS has no least successor.
463 if base.pre is not None:
464 kind, number = base.pre
465 return base.__replace__(pre=(kind, number + 1), post=None, dev=0, local=None)
467 return None
470def range_is_empty(lower: LowerBound, upper: UpperBound) -> bool:
471 """True when the range defined by *lower* and *upper* contains no versions.
473 A boundary lower sits just below the next real version, so an ordered pair
474 is still empty when the upper excludes that least successor:
475 ``(AFTER_POSTS(1.0a1), 1.0a2.dev0)`` holds no version.
476 """
477 if upper.version is None:
478 return False
480 if lower.version is None:
481 # Nothing sorts below MIN_VERSION, so an exclusive upper at or below it
482 # leaves an empty floor interval such as ``(-inf, 0.dev0)``.
483 return (
484 not upper.inclusive
485 and isinstance(upper.version, Version)
486 and upper.version <= MIN_VERSION
487 )
489 if isinstance(lower.version, BoundaryVersion):
490 successor = least_version_above(lower.version)
491 if successor is not None:
492 if upper.version == successor:
493 return not upper.inclusive
494 return upper.version < successor
496 if lower.version == upper.version:
497 return not (lower.inclusive and upper.inclusive)
499 return lower.version > upper.version
502def intersect_ranges(
503 left: Sequence[Interval],
504 right: Sequence[Interval],
505) -> list[Interval]:
506 """Intersect two sorted, non-overlapping range lists (two-pointer merge)."""
507 result: list[Interval] = []
508 left_index = right_index = 0
509 while left_index < len(left) and right_index < len(right):
510 left_lower, left_upper = left[left_index]
511 right_lower, right_upper = right[right_index]
513 lower = max(left_lower, right_lower)
514 upper = min(left_upper, right_upper)
516 if not range_is_empty(lower, upper):
517 result.append((lower, upper))
519 # Advance whichever side has the smaller upper bound.
520 if left_upper < right_upper:
521 left_index += 1
522 else:
523 right_index += 1
525 return result
528def filter_by_ranges(
529 ranges: Sequence[Interval],
530 iterable: Iterable[Any],
531 key: Callable[[Any], Version | str] | None,
532 prereleases: bool | None,
533 region: Sequence[Interval] = (),
534) -> Iterator[Any]:
535 """Filter *iterable* against precomputed version *ranges*.
537 With ``prereleases=None``, the PEP 440 default applies: pre-releases are
538 excluded unless no final matches, in which case buffered pre-releases come
539 out at the end. A pre-release inside the opt-in ``region`` is the exception:
540 it is force-admitted in place, as ``prereleases=True`` would yield it. A
541 force-admitted pre-release is not a final, so it never suppresses the buffer.
542 """
543 if prereleases is None:
544 prerelease_buffer: list[Any] = []
545 found_final = False
547 if len(ranges) == 1:
548 # Hot path: most specifiers and small SpecifierSets reduce to
549 # a single contiguous range.
550 lower, upper = ranges[0]
551 above = lower._above
552 below = upper._below
553 for item in iterable:
554 parsed = coerce_version(item if key is None else key(item))
555 if parsed is None:
556 continue
557 if above is not None and not above(parsed):
558 continue
559 if below is not None and not below(parsed):
560 continue
561 if not parsed.is_prerelease:
562 found_final = True
563 yield item
564 elif region and matches_bounds_only(region, parsed):
565 yield item
566 elif not found_final:
567 prerelease_buffer.append(item)
568 if not found_final:
569 yield from prerelease_buffer
570 return
572 for item in iterable:
573 parsed = coerce_version(item if key is None else key(item))
574 if parsed is None:
575 continue
576 for lower, upper in ranges:
577 above = lower._above
578 if above is not None and not above(parsed):
579 break
580 below = upper._below
581 if below is None or below(parsed):
582 if not parsed.is_prerelease:
583 found_final = True
584 yield item
585 elif region and matches_bounds_only(region, parsed):
586 yield item
587 elif not found_final:
588 prerelease_buffer.append(item)
589 break
590 if not found_final:
591 yield from prerelease_buffer
592 return
594 exclude_prereleases = prereleases is False
596 if len(ranges) == 1:
597 # Hot path: most specifiers and small SpecifierSets reduce to
598 # a single contiguous range.
599 lower, upper = ranges[0]
600 above = lower._above
601 below = upper._below
602 for item in iterable:
603 parsed = coerce_version(item if key is None else key(item))
604 if parsed is None:
605 continue
606 if exclude_prereleases and parsed.is_prerelease:
607 continue
608 if above is not None and not above(parsed):
609 continue
610 if below is None or below(parsed):
611 yield item
612 return
614 for item in iterable:
615 parsed = coerce_version(item if key is None else key(item))
616 if parsed is None:
617 continue
618 if exclude_prereleases and parsed.is_prerelease:
619 continue
620 for lower, upper in ranges:
621 above = lower._above
622 if above is not None and not above(parsed):
623 break
624 below = upper._below
625 if below is None or below(parsed):
626 yield item
627 break
630def _nearest_release_above_prerelease(version: Version) -> Version:
631 """Smallest non-pre-release at or above a pre-release *version*."""
632 if version.pre is not None:
633 # An a/b/rc pre-release drops to its final release, which outranks
634 # every post-release of that pre-release (1.0a1.post0 -> 1.0).
635 return version.__replace__(pre=None, post=None, dev=None, local=None)
637 # A dev-only release keeps its post-release (1.0.post0.dev0 -> 1.0.post0,
638 # whose final 1.0 sorts below it).
639 return version.__replace__(dev=None, local=None)
642def _lowest_release_at_or_above(value: Version | BoundaryVersion | None) -> Version:
643 """Smallest non-pre-release version at or above *value*.
645 ``None`` is the ``-inf`` floor, whose nearest non-pre-release is
646 :data:`MIN_RELEASE`.
647 """
648 if value is None:
649 return MIN_RELEASE
650 if isinstance(value, BoundaryVersion):
651 inner_version = value.version
652 if inner_version.is_prerelease:
653 return _nearest_release_above_prerelease(inner_version)
654 # AFTER_LOCALS(1.0) -> nearest non-pre is 1.0.post0
655 # AFTER_LOCALS(1.0.post0) -> nearest non-pre is 1.0.post1
656 next_post = (inner_version.post + 1) if inner_version.post is not None else 0
657 return inner_version.__replace__(post=next_post, local=None)
659 if not value.is_prerelease:
660 return value
662 return _nearest_release_above_prerelease(value)
665def ranges_are_prerelease_only(ranges: Sequence[Interval]) -> bool:
666 """True when every range in *ranges* contains only pre-releases.
668 Used to detect unsatisfiable specifier sets when ``prereleases=False``:
669 if every range is pre-release-only, every contained version is excluded.
670 """
671 for lower, upper in ranges:
672 nearest = _lowest_release_at_or_above(lower.version)
673 if upper.version is None or nearest < upper.version:
674 return False
675 if nearest == upper.version and upper.inclusive:
676 return False
677 return True
680def wildcard_ranges(op: str, base: Version) -> list[Interval]:
681 """Ranges for ==V.* and !=V.*.
683 ==1.2.* -> [1.2.dev0, 1.3.dev0); !=1.2.* -> complement.
684 """
685 lower = _base_dev0(base)
686 upper = _next_prefix_dev0(base)
687 if op == "==":
688 return [(LowerBound(lower, True), UpperBound(upper, False))]
689 # !=
690 return [
691 (NEG_INF, UpperBound(lower, False)),
692 (LowerBound(upper, True), POS_INF),
693 ]
696def standard_ranges(op: str, version: Version, has_local: bool) -> list[Interval]:
697 """Ranges for the standard PEP 440 operators (no wildcard, no ===).
699 *has_local* indicates whether the spec string included a ``+local``
700 segment; relevant only for ``==`` / ``!=`` to decide whether the
701 upper bound includes V's local family.
702 """
703 if op == ">=":
704 return [(LowerBound(version, True), POS_INF)]
706 if op == "<=":
707 return [
708 (
709 NEG_INF,
710 UpperBound(BoundaryVersion(version, BoundaryKind.AFTER_LOCALS), True),
711 )
712 ]
714 if op == ">":
715 if version.dev is not None:
716 # >V.devN: dev versions have no post-releases, so the
717 # next real version is V.dev(N+1).
718 lower_bound = version.__replace__(dev=version.dev + 1, local=None)
719 return [(LowerBound(lower_bound, True), POS_INF)]
720 if version.post is not None:
721 # >V.postN: next real version is V.post(N+1).dev0.
722 lower_bound = version.__replace__(post=version.post + 1, dev=0, local=None)
723 return [(LowerBound(lower_bound, True), POS_INF)]
724 # >V (final or pre-release V): exclude V itself, V+local, and
725 # every V.postN per PEP 440.
726 return [
727 (
728 LowerBound(BoundaryVersion(version, BoundaryKind.AFTER_POSTS), False),
729 POS_INF,
730 )
731 ]
733 if op == "<":
734 # <V excludes pre-releases of V when V is not a pre-release.
735 # V.dev0 is the earliest pre-release of V.
736 bound = (
737 version if version.is_prerelease else version.__replace__(dev=0, local=None)
738 )
739 if bound <= MIN_VERSION:
740 return []
741 return [(NEG_INF, UpperBound(bound, False))]
743 # ==, !=: local versions of V match when the spec has no local segment.
744 after_locals = BoundaryVersion(version, BoundaryKind.AFTER_LOCALS)
745 upper = version if has_local else after_locals
747 if op == "==":
748 return [(LowerBound(version, True), UpperBound(upper, True))]
750 if op == "!=":
751 return [
752 (NEG_INF, UpperBound(version, False)),
753 (LowerBound(upper, False), POS_INF),
754 ]
756 if op == "~=":
757 prefix = version.__replace__(release=version.release[:-1])
758 return [
759 (LowerBound(version, True), UpperBound(_next_prefix_dev0(prefix), False))
760 ]
762 raise ValueError(f"Unknown operator: {op!r}") # pragma: no cover
765def bounds_for_spec(op: str, version_str: str, version: Version) -> list[Interval]:
766 """Ranges for one specifier's ``(op, version_str)``.
768 Dispatches between the wildcard and standard builders. ``version`` is the
769 parsed ``version_str`` (its base, without the trailing ``.*``, for
770 wildcards). ``===`` is not handled here; its match is a literal string
771 compared in :mod:`packaging.specifiers`.
772 """
773 if version_str.endswith(".*"):
774 return wildcard_ranges(op, version)
776 return standard_ranges(op, version, "+" in version_str)
779def intersect_specifier_bounds(
780 per_specifier_ranges: Iterable[Sequence[Interval]],
781) -> Sequence[Interval]:
782 """Intersect each specifier's ranges into a single sequence.
784 Short-circuits once the running intersection is empty, since no later
785 specifier can revive it. Callers must pass at least one specifier.
786 """
787 result: Sequence[Interval] | None = None
788 for sub in per_specifier_ranges:
789 if result is None:
790 result = sub
791 else:
792 result = intersect_ranges(result, sub)
793 if not result:
794 break
796 if result is None: # pragma: no cover - callers guard non-empty input
797 raise RuntimeError("intersect_specifier_bounds called with no specifiers")
799 return result
802def matches_bounds_only(ranges: Sequence[Interval], version: Version) -> bool:
803 """Whether ``version`` falls within any of ``ranges``.
805 The pure bounds membership test, for a single already-parsed version with
806 no pre-release policy applied. ``ranges`` are sorted and non-overlapping,
807 so a version below one range's lower bound is below every later range too.
808 """
809 for lower, upper in ranges:
810 above = lower._above
811 if above is not None and not above(version):
812 return False
814 below = upper._below
815 if below is None or below(version):
816 return True
818 return False
821def resolve_prereleases(
822 configured: bool | None, autodetected: bool | None
823) -> bool | None:
824 """Resolve a specifier's effective default pre-release policy.
826 An explicit ``configured`` value wins; otherwise an autodetected ``True``
827 propagates and anything else falls back to the PEP 440 default (``None``).
828 """
829 if configured is not None:
830 return configured
832 if autodetected:
833 return True
835 return None