packaging.version Namespace Reference

Classes
class	_BaseVersion
class	_TrimmedRelease
class	_Version
class	InvalidVersion
class	Version

Functions
Version	parse (str version)
tuple[str, int]|None	_parse_letter_version (str|None letter, str|bytes|SupportsInt|None number)
LocalType|None	_parse_local_version (str|None local)
CmpKey	_cmpkey (int epoch, tuple[int,...] release, tuple[str, int]|None pre, tuple[str, int]|None post, tuple[str, int]|None dev, LocalType|None local)

Variables
	LocalType = Tuple[Union[int, str], ...]
	CmpPrePostDevType = Union[InfinityType, NegativeInfinityType, Tuple[str, int]]
	CmpLocalType
	CmpKey
	VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool]
str	_VERSION_PATTERN
str	VERSION_PATTERN = _VERSION_PATTERN
	_local_version_separators = re.compile(r"[\._-]")

Detailed Description

.. testsetup::

    from packaging.version import parse, Version

Function Documentation

_parse_local_version()

LocalType | None packaging.version._parse_local_version ( str | None  local )

protected

Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").

parse()

Version packaging.version.parse

(

str

version

)

Parse the given version string.

>>> parse('1.0.dev1')
<Version('1.0.dev1')>

:param version: The version string to parse.
:raises InvalidVersion: When the version string is not a valid version.

Variable Documentation

_VERSION_PATTERN

str packaging.version._VERSION_PATTERN

protected

Initial value:

=  r"""
    v?
    (?:
        (?:(?P<epoch>[0-9]+)!)?                           # epoch
        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
        (?P<pre>                                          # pre-release
            [-_\.]?
            (?P<pre_l>alpha|a|beta|b|preview|pre|c|rc)
            [-_\.]?
            (?P<pre_n>[0-9]+)?
        )?
        (?P<post>                                         # post release
            (?:-(?P<post_n1>[0-9]+))
            |
            (?:
                [-_\.]?
                (?P<post_l>post|rev|r)
                [-_\.]?
                (?P<post_n2>[0-9]+)?
            )
        )?
        (?P<dev>                                          # dev release
            [-_\.]?
            (?P<dev_l>dev)
            [-_\.]?
            (?P<dev_n>[0-9]+)?
        )?
    )
    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
"""

CmpKey

packaging.version.CmpKey

Initial value:

=  Tuple[
    int,
    Tuple[int, ...],
    CmpPrePostDevType,
    CmpPrePostDevType,
    CmpPrePostDevType,
    CmpLocalType,
]

CmpLocalType

packaging.version.CmpLocalType

Initial value:

=  Union[
    NegativeInfinityType,
    Tuple[Union[Tuple[int, str], Tuple[NegativeInfinityType, Union[int, str]]], ...],
]