Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.11/site-packages/packaging/version.py: 3%
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"""
5.. testsetup::
7 from packaging.version import parse, normalize_pre, Version, _cmpkey
8"""
10from __future__ import annotations
12import re
13import sys
14import typing
15from typing import (
16 Any,
17 Callable,
18 Literal,
19 NamedTuple,
20 SupportsInt,
21 Tuple,
22 TypedDict,
23 Union,
24)
26if typing.TYPE_CHECKING:
27 from typing_extensions import Self, Unpack
29if sys.version_info >= (3, 13): # pragma: no cover
30 from warnings import deprecated as _deprecated
31elif typing.TYPE_CHECKING:
32 from typing_extensions import deprecated as _deprecated
33else: # pragma: no cover
34 import functools
35 import warnings
37 def _deprecated(message: str) -> object:
38 def decorator(func: Callable[[...], object]) -> object:
39 @functools.wraps(func)
40 def wrapper(*args: object, **kwargs: object) -> object:
41 warnings.warn(
42 message,
43 category=DeprecationWarning,
44 stacklevel=2,
45 )
46 return func(*args, **kwargs)
48 return wrapper
50 return decorator
53_LETTER_NORMALIZATION = {
54 "alpha": "a",
55 "beta": "b",
56 "c": "rc",
57 "pre": "rc",
58 "preview": "rc",
59 "rev": "post",
60 "r": "post",
61}
63__all__ = ["VERSION_PATTERN", "InvalidVersion", "Version", "normalize_pre", "parse"]
66def __dir__() -> list[str]:
67 return __all__
70LocalType = Tuple[Union[int, str], ...]
72CmpLocalType = Tuple[Tuple[int, str], ...]
73CmpSuffix = Tuple[int, int, int, int, int, int]
74CmpKey = Union[
75 Tuple[int, Tuple[int, ...], CmpSuffix],
76 Tuple[int, Tuple[int, ...], CmpSuffix, CmpLocalType],
77]
78VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool]
81class _VersionReplace(TypedDict, total=False):
82 epoch: int | None
83 release: tuple[int, ...] | None
84 pre: tuple[str, int] | None
85 post: int | None
86 dev: int | None
87 local: str | None
90def normalize_pre(letter: str, /) -> str:
91 """Normalize the pre-release segment of a version string.
93 Returns a lowercase version of the string if not a known pre-release
94 identifier.
96 >>> normalize_pre('alpha')
97 'a'
98 >>> normalize_pre('BETA')
99 'b'
100 >>> normalize_pre('rc')
101 'rc'
103 :param letter:
105 .. versionadded:: 26.1
106 """
107 letter = letter.lower()
108 return _LETTER_NORMALIZATION.get(letter, letter)
111def parse(version: str) -> Version:
112 """Parse the given version string.
114 This is identical to the :class:`Version` constructor.
116 >>> parse('1.0.dev1')
117 <Version('1.0.dev1')>
119 :param version: The version string to parse.
120 :raises InvalidVersion: When the version string is not a valid version.
121 """
122 return Version(version)
125class InvalidVersion(ValueError):
126 """Raised when a version string is not a valid version.
128 >>> Version("invalid")
129 Traceback (most recent call last):
130 ...
131 packaging.version.InvalidVersion: Invalid version: 'invalid'
132 """
135class _BaseVersion:
136 __slots__ = ()
138 # This can also be a normal member (see the packaging_legacy package);
139 # we are just requiring it to be readable. Actually defining a property
140 # has runtime effect on subclasses, so it's typing only.
141 if typing.TYPE_CHECKING:
143 @property
144 def _key(self) -> tuple[Any, ...]: ...
146 def __hash__(self) -> int:
147 return hash(self._key)
149 # Please keep the duplicated `isinstance` check
150 # in the six comparisons hereunder
151 # unless you find a way to avoid adding overhead function calls.
152 def __lt__(self, other: _BaseVersion) -> bool:
153 if not isinstance(other, _BaseVersion):
154 return NotImplemented
156 return self._key < other._key
158 def __le__(self, other: _BaseVersion) -> bool:
159 if not isinstance(other, _BaseVersion):
160 return NotImplemented
162 return self._key <= other._key
164 def __eq__(self, other: object) -> bool:
165 if not isinstance(other, _BaseVersion):
166 return NotImplemented
168 return self._key == other._key
170 def __ge__(self, other: _BaseVersion) -> bool:
171 if not isinstance(other, _BaseVersion):
172 return NotImplemented
174 return self._key >= other._key
176 def __gt__(self, other: _BaseVersion) -> bool:
177 if not isinstance(other, _BaseVersion):
178 return NotImplemented
180 return self._key > other._key
182 def __ne__(self, other: object) -> bool:
183 if not isinstance(other, _BaseVersion):
184 return NotImplemented
186 return self._key != other._key
189# Deliberately not anchored to the start and end of the string, to make it
190# easier for 3rd party code to reuse
192# Note that ++ doesn't behave identically on CPython and PyPy, so not using it here
193_VERSION_PATTERN = r"""
194 v?+ # optional leading v
195 (?a:
196 (?:(?P<epoch>[0-9]+)!)?+ # epoch
197 (?P<release>[0-9]+(?:\.[0-9]+)*+) # release segment
198 (?P<pre> # pre-release
199 [._-]?+
200 (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)
201 [._-]?+
202 (?P<pre_n>[0-9]+)?
203 )?+
204 (?P<post> # post release
205 (?:-(?P<post_n1>[0-9]+))
206 |
207 (?:
208 [._-]?
209 (?P<post_l>post|rev|r)
210 [._-]?
211 (?P<post_n2>[0-9]+)?
212 )
213 )?+
214 (?P<dev> # dev release
215 [._-]?+
216 (?P<dev_l>dev)
217 [._-]?+
218 (?P<dev_n>[0-9]+)?
219 )?+
220 )
221 (?a:\+
222 (?P<local> # local version
223 [a-z0-9]+
224 (?:[._-][a-z0-9]+)*+
225 )
226 )?+
227"""
229_VERSION_PATTERN_OLD = _VERSION_PATTERN.replace("*+", "*").replace("?+", "?")
231# Possessive qualifiers were added in Python 3.11.
232# CPython 3.11.0-3.11.4 had a bug: https://github.com/python/cpython/pull/107795
233# Older PyPy also had a bug.
234VERSION_PATTERN = (
235 _VERSION_PATTERN_OLD
236 if (sys.implementation.name == "cpython" and sys.version_info < (3, 11, 5))
237 or (sys.implementation.name == "pypy" and sys.version_info < (3, 11, 13))
238 or sys.version_info < (3, 11)
239 else _VERSION_PATTERN
240)
241"""
242A string containing the regular expression used to match a valid version.
244The pattern is not anchored at either end, and is intended for embedding in larger
245expressions (for example, matching a version number as part of a file name). The
246regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
247flags set.
249.. versionchanged:: 26.0
251 The regex now uses possessive qualifiers on Python 3.11 if they are
252 supported (CPython 3.11.5+, PyPy 3.11.13+).
254:meta hide-value:
255"""
258# Validation pattern for local version in replace()
259_LOCAL_PATTERN = re.compile(r"[a-z0-9]+(?:[._-][a-z0-9]+)*", re.IGNORECASE | re.ASCII)
261# Fast path: If a version has only digits and dots then we
262# can skip the regex and parse it as a release segment
263_SIMPLE_VERSION_INDICATORS = frozenset(".0123456789")
266def _validate_epoch(value: object, /) -> int:
267 epoch = value or 0
268 if isinstance(epoch, int) and epoch >= 0:
269 return epoch
270 msg = f"epoch must be non-negative integer, got {epoch}"
271 raise InvalidVersion(msg)
274def _validate_release(value: object, /) -> tuple[int, ...]:
275 release = (0,) if value is None else value
276 if (
277 isinstance(release, tuple)
278 and len(release) > 0
279 and all(isinstance(i, int) and i >= 0 for i in release)
280 ):
281 return release
282 msg = f"release must be a non-empty tuple of non-negative integers, got {release}"
283 raise InvalidVersion(msg)
286def _validate_pre(value: object, /) -> tuple[Literal["a", "b", "rc"], int] | None:
287 if value is None:
288 return value
289 if isinstance(value, tuple) and len(value) == 2:
290 letter, number = value
291 letter = normalize_pre(letter)
292 if letter in {"a", "b", "rc"} and isinstance(number, int) and number >= 0:
293 # type checkers can't infer the Literal type here on letter
294 return (letter, number) # type: ignore[return-value]
295 msg = f"pre must be a tuple of ('a'|'b'|'rc', non-negative int), got {value}"
296 raise InvalidVersion(msg)
299def _validate_post(value: object, /) -> tuple[Literal["post"], int] | None:
300 if value is None:
301 return value
302 if isinstance(value, int) and value >= 0:
303 return ("post", value)
304 msg = f"post must be non-negative integer, got {value}"
305 raise InvalidVersion(msg)
308def _validate_dev(value: object, /) -> tuple[Literal["dev"], int] | None:
309 if value is None:
310 return value
311 if isinstance(value, int) and value >= 0:
312 return ("dev", value)
313 msg = f"dev must be non-negative integer, got {value}"
314 raise InvalidVersion(msg)
317def _validate_local(value: object, /) -> LocalType | None:
318 if value is None:
319 return value
320 if isinstance(value, str) and _LOCAL_PATTERN.fullmatch(value):
321 return _parse_local_version(value)
322 msg = f"local must be a valid version string, got {value!r}"
323 raise InvalidVersion(msg)
326# Backward compatibility for internals before 26.0. Do not use.
327class _Version(NamedTuple):
328 epoch: int
329 release: tuple[int, ...]
330 dev: tuple[Literal["dev"], int] | None
331 pre: tuple[Literal["a", "b", "rc"], int] | None
332 post: tuple[Literal["post"], int] | None
333 local: LocalType | None
336class Version(_BaseVersion):
337 """This class abstracts handling of a project's versions.
339 A :class:`Version` instance is comparison aware and can be compared and
340 sorted using the standard Python interfaces.
342 >>> v1 = Version("1.0a5")
343 >>> v2 = Version("1.0")
344 >>> v1
345 <Version('1.0a5')>
346 >>> v2
347 <Version('1.0')>
348 >>> v1 < v2
349 True
350 >>> v1 == v2
351 False
352 >>> v1 > v2
353 False
354 >>> v1 >= v2
355 False
356 >>> v1 <= v2
357 True
359 :class:`Version` is immutable; use :meth:`__replace__` to change
360 part of a version.
361 """
363 __slots__ = (
364 "_dev",
365 "_epoch",
366 "_hash_cache",
367 "_key_cache",
368 "_local",
369 "_post",
370 "_pre",
371 "_release",
372 )
373 __match_args__ = ("_str",)
374 """
375 Pattern matching is supported on Python 3.10+.
377 .. versionadded:: 26.0
379 :meta hide-value:
380 """
382 _regex = re.compile(r"\s*" + VERSION_PATTERN + r"\s*", re.VERBOSE | re.IGNORECASE)
384 _epoch: int
385 _release: tuple[int, ...]
386 _dev: tuple[Literal["dev"], int] | None
387 _pre: tuple[Literal["a", "b", "rc"], int] | None
388 _post: tuple[Literal["post"], int] | None
389 _local: LocalType | None
391 _hash_cache: int | None
392 _key_cache: CmpKey | None
394 def __init__(self, version: str) -> None:
395 """Initialize a Version object.
397 :param version:
398 The string representation of a version which will be parsed and normalized
399 before use.
400 :raises InvalidVersion:
401 If the ``version`` does not conform to PEP 440 in any way then this
402 exception will be raised.
403 """
404 if _SIMPLE_VERSION_INDICATORS.issuperset(version):
405 try:
406 self._release = tuple(map(int, version.split(".")))
407 except ValueError:
408 # Empty parts (from "1..2", ".1", etc.) are invalid versions.
409 # Any other ValueError (e.g. int str-digits limit) should
410 # propagate to the caller.
411 if "" in version.split("."):
412 raise InvalidVersion(f"Invalid version: {version!r}") from None
413 # TODO: remove "no cover" when Python 3.9 is dropped.
414 raise # pragma: no cover
416 self._epoch = 0
417 self._pre = None
418 self._post = None
419 self._dev = None
420 self._local = None
421 self._key_cache = None
422 self._hash_cache = None
423 return
425 # Validate the version and parse it into pieces
426 match = self._regex.fullmatch(version)
427 if not match:
428 raise InvalidVersion(f"Invalid version: {version!r}")
429 self._epoch = int(match.group("epoch")) if match.group("epoch") else 0
430 self._release = tuple(map(int, match.group("release").split(".")))
431 # We can type ignore the assignments below because the regex guarantees
432 # the correct strings
433 self._pre = _parse_letter_version(match.group("pre_l"), match.group("pre_n")) # type: ignore[assignment]
434 self._post = _parse_letter_version( # type: ignore[assignment]
435 match.group("post_l"), match.group("post_n1") or match.group("post_n2")
436 )
437 self._dev = _parse_letter_version(match.group("dev_l"), match.group("dev_n")) # type: ignore[assignment]
438 self._local = _parse_local_version(match.group("local"))
440 # Key which will be used for sorting
441 self._key_cache = None
442 self._hash_cache = None
444 @classmethod
445 def from_parts(
446 cls,
447 *,
448 epoch: int = 0,
449 release: tuple[int, ...],
450 pre: tuple[str, int] | None = None,
451 post: int | None = None,
452 dev: int | None = None,
453 local: str | None = None,
454 ) -> Self:
455 """
456 Return a new version composed of the various parts.
458 This allows you to build a version without going though a string and
459 running a regular expression. It normalizes pre-release strings. The
460 ``release=`` keyword argument is required.
462 >>> Version.from_parts(release=(1,2,3))
463 <Version('1.2.3')>
464 >>> Version.from_parts(release=(0,1,0), pre=("b", 1))
465 <Version('0.1.0b1')>
467 :param epoch:
468 :param release: This version tuple is required
470 .. versionadded:: 26.1
471 """
472 _epoch = _validate_epoch(epoch)
473 _release = _validate_release(release)
474 _pre = _validate_pre(pre) if pre is not None else None
475 _post = _validate_post(post) if post is not None else None
476 _dev = _validate_dev(dev) if dev is not None else None
477 _local = _validate_local(local) if local is not None else None
479 new_version = cls.__new__(cls)
480 new_version._key_cache = None
481 new_version._hash_cache = None
482 new_version._epoch = _epoch
483 new_version._release = _release
484 new_version._pre = _pre
485 new_version._post = _post
486 new_version._dev = _dev
487 new_version._local = _local
489 return new_version
491 def __replace__(self, **kwargs: Unpack[_VersionReplace]) -> Self:
492 """
493 __replace__(*, epoch=..., release=..., pre=..., post=..., dev=..., local=...)
495 Return a new version with parts replaced.
497 This returns a new version (unless no parts were changed). The
498 pre-release is normalized. Setting a value to ``None`` clears it.
500 >>> v = Version("1.2.3")
501 >>> v.__replace__(pre=("a", 1))
502 <Version('1.2.3a1')>
504 :param int | None epoch:
505 :param tuple[int, ...] | None release:
506 :param tuple[str, int] | None pre:
507 :param int | None post:
508 :param int | None dev:
509 :param str | None local:
511 .. versionadded:: 26.0
512 .. versionchanged:: 26.1
514 The pre-release portion is now normalized.
515 """
516 epoch = _validate_epoch(kwargs["epoch"]) if "epoch" in kwargs else self._epoch
517 release = (
518 _validate_release(kwargs["release"])
519 if "release" in kwargs
520 else self._release
521 )
522 pre = _validate_pre(kwargs["pre"]) if "pre" in kwargs else self._pre
523 post = _validate_post(kwargs["post"]) if "post" in kwargs else self._post
524 dev = _validate_dev(kwargs["dev"]) if "dev" in kwargs else self._dev
525 local = _validate_local(kwargs["local"]) if "local" in kwargs else self._local
527 if (
528 epoch == self._epoch
529 and release == self._release
530 and pre == self._pre
531 and post == self._post
532 and dev == self._dev
533 and local == self._local
534 ):
535 return self
537 new_version = self.__class__.__new__(self.__class__)
538 new_version._key_cache = None
539 new_version._hash_cache = None
540 new_version._epoch = epoch
541 new_version._release = release
542 new_version._pre = pre
543 new_version._post = post
544 new_version._dev = dev
545 new_version._local = local
547 return new_version
549 @property
550 def _key(self) -> CmpKey:
551 if self._key_cache is None:
552 self._key_cache = _cmpkey(
553 self._epoch,
554 self._release,
555 self._pre,
556 self._post,
557 self._dev,
558 self._local,
559 )
560 return self._key_cache
562 # __hash__ must be defined when __eq__ is overridden,
563 # otherwise Python sets __hash__ to None.
564 def __hash__(self) -> int:
565 if (cached_hash := self._hash_cache) is not None:
566 return cached_hash
568 if (key := self._key_cache) is None:
569 self._key_cache = key = _cmpkey(
570 self._epoch,
571 self._release,
572 self._pre,
573 self._post,
574 self._dev,
575 self._local,
576 )
577 self._hash_cache = cached_hash = hash(key)
578 return cached_hash
580 # Override comparison methods to use direct _key_cache access
581 # This is faster than property access, especially before Python 3.12
582 def __lt__(self, other: _BaseVersion) -> bool:
583 if isinstance(other, Version):
584 if self._key_cache is None:
585 self._key_cache = _cmpkey(
586 self._epoch,
587 self._release,
588 self._pre,
589 self._post,
590 self._dev,
591 self._local,
592 )
593 if other._key_cache is None:
594 other._key_cache = _cmpkey(
595 other._epoch,
596 other._release,
597 other._pre,
598 other._post,
599 other._dev,
600 other._local,
601 )
602 return self._key_cache < other._key_cache
604 if not isinstance(other, _BaseVersion):
605 return NotImplemented
607 return super().__lt__(other)
609 def __le__(self, other: _BaseVersion) -> bool:
610 if isinstance(other, Version):
611 if self._key_cache is None:
612 self._key_cache = _cmpkey(
613 self._epoch,
614 self._release,
615 self._pre,
616 self._post,
617 self._dev,
618 self._local,
619 )
620 if other._key_cache is None:
621 other._key_cache = _cmpkey(
622 other._epoch,
623 other._release,
624 other._pre,
625 other._post,
626 other._dev,
627 other._local,
628 )
629 return self._key_cache <= other._key_cache
631 if not isinstance(other, _BaseVersion):
632 return NotImplemented
634 return super().__le__(other)
636 def __eq__(self, other: object) -> bool:
637 if isinstance(other, Version):
638 if self._key_cache is None:
639 self._key_cache = _cmpkey(
640 self._epoch,
641 self._release,
642 self._pre,
643 self._post,
644 self._dev,
645 self._local,
646 )
647 if other._key_cache is None:
648 other._key_cache = _cmpkey(
649 other._epoch,
650 other._release,
651 other._pre,
652 other._post,
653 other._dev,
654 other._local,
655 )
656 return self._key_cache == other._key_cache
658 if not isinstance(other, _BaseVersion):
659 return NotImplemented
661 return super().__eq__(other)
663 def __ge__(self, other: _BaseVersion) -> bool:
664 if isinstance(other, Version):
665 if self._key_cache is None:
666 self._key_cache = _cmpkey(
667 self._epoch,
668 self._release,
669 self._pre,
670 self._post,
671 self._dev,
672 self._local,
673 )
674 if other._key_cache is None:
675 other._key_cache = _cmpkey(
676 other._epoch,
677 other._release,
678 other._pre,
679 other._post,
680 other._dev,
681 other._local,
682 )
683 return self._key_cache >= other._key_cache
685 if not isinstance(other, _BaseVersion):
686 return NotImplemented
688 return super().__ge__(other)
690 def __gt__(self, other: _BaseVersion) -> bool:
691 if isinstance(other, Version):
692 if self._key_cache is None:
693 self._key_cache = _cmpkey(
694 self._epoch,
695 self._release,
696 self._pre,
697 self._post,
698 self._dev,
699 self._local,
700 )
701 if other._key_cache is None:
702 other._key_cache = _cmpkey(
703 other._epoch,
704 other._release,
705 other._pre,
706 other._post,
707 other._dev,
708 other._local,
709 )
710 return self._key_cache > other._key_cache
712 if not isinstance(other, _BaseVersion):
713 return NotImplemented
715 return super().__gt__(other)
717 def __ne__(self, other: object) -> bool:
718 if isinstance(other, Version):
719 if self._key_cache is None:
720 self._key_cache = _cmpkey(
721 self._epoch,
722 self._release,
723 self._pre,
724 self._post,
725 self._dev,
726 self._local,
727 )
728 if other._key_cache is None:
729 other._key_cache = _cmpkey(
730 other._epoch,
731 other._release,
732 other._pre,
733 other._post,
734 other._dev,
735 other._local,
736 )
737 return self._key_cache != other._key_cache
739 if not isinstance(other, _BaseVersion):
740 return NotImplemented
742 return super().__ne__(other)
744 @property
745 @_deprecated("Version._version is private and will be removed soon")
746 def _version(self) -> _Version:
747 return _Version(
748 self._epoch, self._release, self._dev, self._pre, self._post, self._local
749 )
751 @_version.setter
752 @_deprecated("Version._version is private and will be removed soon")
753 def _version(self, value: _Version) -> None:
754 self._epoch = value.epoch
755 self._release = value.release
756 self._dev = value.dev
757 self._pre = value.pre
758 self._post = value.post
759 self._local = value.local
760 self._key_cache = None
761 self._hash_cache = None
763 def __repr__(self) -> str:
764 """A representation of the Version that shows all internal state.
766 >>> Version('1.0.0')
767 <Version('1.0.0')>
768 """
769 return f"<{self.__class__.__name__}({str(self)!r})>"
771 def __str__(self) -> str:
772 """A string representation of the version that can be round-tripped.
774 >>> str(Version("1.0a5"))
775 '1.0a5'
776 """
777 # This is a hot function, so not calling self.base_version
778 version = ".".join(map(str, self.release))
780 # Epoch
781 if self.epoch:
782 version = f"{self.epoch}!{version}"
784 # Pre-release
785 if self.pre is not None:
786 version += "".join(map(str, self.pre))
788 # Post-release
789 if self.post is not None:
790 version += f".post{self.post}"
792 # Development release
793 if self.dev is not None:
794 version += f".dev{self.dev}"
796 # Local version segment
797 if self.local is not None:
798 version += f"+{self.local}"
800 return version
802 @property
803 def _str(self) -> str:
804 """Internal property for match_args"""
805 return str(self)
807 @property
808 def epoch(self) -> int:
809 """The epoch of the version.
811 >>> Version("2.0.0").epoch
812 0
813 >>> Version("1!2.0.0").epoch
814 1
815 """
816 return self._epoch
818 @property
819 def release(self) -> tuple[int, ...]:
820 """The components of the "release" segment of the version.
822 >>> Version("1.2.3").release
823 (1, 2, 3)
824 >>> Version("2.0.0").release
825 (2, 0, 0)
826 >>> Version("1!2.0.0.post0").release
827 (2, 0, 0)
829 Includes trailing zeroes but not the epoch or any pre-release / development /
830 post-release suffixes.
831 """
832 return self._release
834 @property
835 def pre(self) -> tuple[Literal["a", "b", "rc"], int] | None:
836 """The pre-release segment of the version.
838 >>> print(Version("1.2.3").pre)
839 None
840 >>> Version("1.2.3a1").pre
841 ('a', 1)
842 >>> Version("1.2.3b1").pre
843 ('b', 1)
844 >>> Version("1.2.3rc1").pre
845 ('rc', 1)
846 """
847 return self._pre
849 @property
850 def post(self) -> int | None:
851 """The post-release number of the version.
853 >>> print(Version("1.2.3").post)
854 None
855 >>> Version("1.2.3.post1").post
856 1
857 """
858 return self._post[1] if self._post else None
860 @property
861 def dev(self) -> int | None:
862 """The development number of the version.
864 >>> print(Version("1.2.3").dev)
865 None
866 >>> Version("1.2.3.dev1").dev
867 1
868 """
869 return self._dev[1] if self._dev else None
871 @property
872 def local(self) -> str | None:
873 """The local version segment of the version.
875 >>> print(Version("1.2.3").local)
876 None
877 >>> Version("1.2.3+abc").local
878 'abc'
879 """
880 if self._local:
881 return ".".join(str(x) for x in self._local)
882 else:
883 return None
885 @property
886 def public(self) -> str:
887 """The public portion of the version.
889 This returns a string. If you want a :class:`Version` again and care
890 about performance, use ``v.__replace__(local=None)`` instead.
892 >>> Version("1.2.3").public
893 '1.2.3'
894 >>> Version("1.2.3+abc").public
895 '1.2.3'
896 >>> Version("1!1.2.3dev1+abc").public
897 '1!1.2.3.dev1'
898 """
899 return str(self).split("+", 1)[0]
901 @property
902 def base_version(self) -> str:
903 """The "base version" of the version.
905 This returns a string. If you want a :class:`Version` again and care
906 about performance, use
907 ``v.__replace__(pre=None, post=None, dev=None, local=None)`` instead.
909 >>> Version("1.2.3").base_version
910 '1.2.3'
911 >>> Version("1.2.3+abc").base_version
912 '1.2.3'
913 >>> Version("1!1.2.3dev1+abc").base_version
914 '1!1.2.3'
916 The "base version" is the public version of the project without any pre or post
917 release markers.
918 """
919 release_segment = ".".join(map(str, self.release))
920 return f"{self.epoch}!{release_segment}" if self.epoch else release_segment
922 @property
923 def is_prerelease(self) -> bool:
924 """Whether this version is a pre-release.
926 >>> Version("1.2.3").is_prerelease
927 False
928 >>> Version("1.2.3a1").is_prerelease
929 True
930 >>> Version("1.2.3b1").is_prerelease
931 True
932 >>> Version("1.2.3rc1").is_prerelease
933 True
934 >>> Version("1.2.3dev1").is_prerelease
935 True
936 """
937 return self.dev is not None or self.pre is not None
939 @property
940 def is_postrelease(self) -> bool:
941 """Whether this version is a post-release.
943 >>> Version("1.2.3").is_postrelease
944 False
945 >>> Version("1.2.3.post1").is_postrelease
946 True
947 """
948 return self.post is not None
950 @property
951 def is_devrelease(self) -> bool:
952 """Whether this version is a development release.
954 >>> Version("1.2.3").is_devrelease
955 False
956 >>> Version("1.2.3.dev1").is_devrelease
957 True
958 """
959 return self.dev is not None
961 @property
962 def major(self) -> int:
963 """The first item of :attr:`release` or ``0`` if unavailable.
965 >>> Version("1.2.3").major
966 1
967 """
968 return self.release[0] if len(self.release) >= 1 else 0
970 @property
971 def minor(self) -> int:
972 """The second item of :attr:`release` or ``0`` if unavailable.
974 >>> Version("1.2.3").minor
975 2
976 >>> Version("1").minor
977 0
978 """
979 return self.release[1] if len(self.release) >= 2 else 0
981 @property
982 def micro(self) -> int:
983 """The third item of :attr:`release` or ``0`` if unavailable.
985 >>> Version("1.2.3").micro
986 3
987 >>> Version("1").micro
988 0
989 """
990 return self.release[2] if len(self.release) >= 3 else 0
993class _TrimmedRelease(Version):
994 __slots__ = ()
996 def __init__(self, version: str | Version) -> None:
997 if isinstance(version, Version):
998 self._epoch = version._epoch
999 self._release = version._release
1000 self._dev = version._dev
1001 self._pre = version._pre
1002 self._post = version._post
1003 self._local = version._local
1004 self._key_cache = version._key_cache
1005 return
1006 super().__init__(version) # pragma: no cover
1008 @property
1009 def release(self) -> tuple[int, ...]:
1010 """
1011 Release segment without any trailing zeros.
1013 >>> _TrimmedRelease('1.0.0').release
1014 (1,)
1015 >>> _TrimmedRelease('0.0').release
1016 (0,)
1017 """
1018 # This leaves one 0.
1019 rel = super().release
1020 len_release = len(rel)
1021 i = len_release
1022 while i > 1 and rel[i - 1] == 0:
1023 i -= 1
1024 return rel if i == len_release else rel[:i]
1027def _parse_letter_version(
1028 letter: str | None, number: str | bytes | SupportsInt | None
1029) -> tuple[str, int] | None:
1030 if letter:
1031 # We normalize any letters to their lower case form
1032 letter = letter.lower()
1034 # We consider some words to be alternate spellings of other words and
1035 # in those cases we want to normalize the spellings to our preferred
1036 # spelling.
1037 letter = _LETTER_NORMALIZATION.get(letter, letter)
1039 # We consider there to be an implicit 0 in a pre-release if there is
1040 # not a numeral associated with it.
1041 return letter, int(number or 0)
1043 if number:
1044 # We assume if we are given a number, but we are not given a letter
1045 # then this is using the implicit post release syntax (e.g. 1.0-1)
1046 return "post", int(number)
1048 return None
1051_local_version_separators = re.compile(r"[\._-]")
1054def _parse_local_version(local: str | None) -> LocalType | None:
1055 """
1056 Takes a string like ``"abc.1.twelve"`` and turns it into
1057 ``("abc", 1, "twelve")``.
1058 """
1059 if local is not None:
1060 return tuple(
1061 part.lower() if not part.isdigit() else int(part)
1062 for part in _local_version_separators.split(local)
1063 )
1064 return None
1067# Sort ranks for pre-release: dev-only < a < b < rc < stable (no pre-release).
1068_PRE_RANK = {"a": 0, "b": 1, "rc": 2}
1069_PRE_RANK_DEV_ONLY = -1 # sorts before a(0)
1070_PRE_RANK_STABLE = 3 # sorts after rc(2)
1072# In local version segments, strings sort before ints per PEP 440.
1073_LOCAL_STR_RANK = -1 # sorts before all non-negative ints
1075# Pre-computed suffix for stable releases (no pre, post, or dev segments).
1076# See _cmpkey() for the suffix layout.
1077_STABLE_SUFFIX = (_PRE_RANK_STABLE, 0, 0, 0, 1, 0)
1080def _cmpkey(
1081 epoch: int,
1082 release: tuple[int, ...],
1083 pre: tuple[str, int] | None,
1084 post: tuple[str, int] | None,
1085 dev: tuple[str, int] | None,
1086 local: LocalType | None,
1087) -> CmpKey:
1088 """Build a comparison key for PEP 440 ordering.
1090 Returns ``(epoch, release, suffix)`` or
1091 ``(epoch, release, suffix, local)`` so that plain tuple
1092 comparison gives the correct order.
1094 Trailing zeros are stripped from the release so that ``1.0.0 == 1``.
1096 The suffix is a flat 6-int tuple that encodes pre/post/dev:
1097 ``(pre_rank, pre_n, post_rank, post_n, dev_rank, dev_n)``
1099 pre_rank: dev-only=-1, a=0, b=1, rc=2, no-pre=3
1100 Dev-only releases (no pre or post) get -1 so they sort before
1101 any alpha/beta/rc. Releases without a pre-release tag get 3
1102 so they sort after rc.
1103 post_rank: no-post=0, post=1
1104 Releases without a post segment sort before those with one.
1105 dev_rank: dev=0, no-dev=1
1106 Releases without a dev segment sort after those with one.
1108 Local segments use ``(n, "")`` for ints and ``(-1, s)`` for strings,
1109 following PEP 440: strings sort before ints, strings compare
1110 lexicographically, ints compare numerically, and shorter segments
1111 sort before longer when prefixes match. Versions without a local
1112 segment sort before those with one (3-tuple < 4-tuple).
1114 >>> _cmpkey(0, (1, 0, 0), None, None, None, None)
1115 (0, (1,), (3, 0, 0, 0, 1, 0))
1116 >>> _cmpkey(0, (1,), ("a", 1), None, None, None)
1117 (0, (1,), (0, 1, 0, 0, 1, 0))
1118 >>> _cmpkey(0, (1,), None, None, None, ("ubuntu", 1))
1119 (0, (1,), (3, 0, 0, 0, 1, 0), ((-1, 'ubuntu'), (1, '')))
1120 """
1121 # Strip trailing zeros: 1.0.0 compares equal to 1.
1122 len_release = len(release)
1123 i = len_release
1124 while i and release[i - 1] == 0:
1125 i -= 1
1126 trimmed = release if i == len_release else release[:i]
1128 # Fast path: stable release with no local segment.
1129 if pre is None and post is None and dev is None and local is None:
1130 return epoch, trimmed, _STABLE_SUFFIX
1132 if pre is None and post is None and dev is not None:
1133 # dev-only (e.g. 1.0.dev1) sorts before all pre-releases.
1134 pre_rank, pre_n = _PRE_RANK_DEV_ONLY, 0
1135 elif pre is None:
1136 pre_rank, pre_n = _PRE_RANK_STABLE, 0
1137 else:
1138 pre_rank, pre_n = _PRE_RANK[pre[0]], pre[1]
1140 post_rank = 0 if post is None else 1
1141 post_n = 0 if post is None else post[1]
1143 dev_rank = 1 if dev is None else 0
1144 dev_n = 0 if dev is None else dev[1]
1146 suffix = (pre_rank, pre_n, post_rank, post_n, dev_rank, dev_n)
1148 if local is None:
1149 return epoch, trimmed, suffix
1151 cmp_local: CmpLocalType = tuple(
1152 (seg, "") if isinstance(seg, int) else (_LOCAL_STR_RANK, seg) for seg in local
1153 )
1154 return epoch, trimmed, suffix, cmp_local