pip._vendor.distlib.version Namespace Reference

Classes
class	LegacyMatcher
class	LegacyVersion
class	Matcher
class	NormalizedMatcher
class	NormalizedVersion
class	SemanticMatcher
class	SemanticVersion
class	UnsupportedVersionError
class	Version
class	VersionScheme

Functions
	_pep_440_key (s)
	_match_prefix (x, y)
	_suggest_semantic_version (s)
	_suggest_normalized_version (s)
	_legacy_key (s)
	is_semver (s)
	_semantic_key (s)
	get_scheme (name)

Variables
	logger = logging.getLogger(__name__)
	PEP440_VERSION_RE
	_normalized_key = _pep_440_key
tuple	_REPLACEMENTS
tuple	_SUFFIX_REPLACEMENTS
	_NUMERIC_PREFIX = re.compile(r'(\d+(\.\d+)*)')
	_VERSION_PART = re.compile(r'([a-z]+|\d+|[\.-])', re.I)
dict	_VERSION_REPLACE
	_SEMVER_RE
dict	_SCHEMES

Detailed Description

Implementation of a flexible versioning scheme providing support for PEP-440,
setuptools-compatible and semantic versioning.

Function Documentation

_suggest_normalized_version()

pip._vendor.distlib.version._suggest_normalized_version (   s )

protected

Suggest a normalized version close to the given version string.

If you have a version string that isn't rational (i.e. NormalizedVersion
doesn't like it) then you might be able to get an equivalent (or close)
rational version from this function.

This does a number of simple normalizations to the given string, based
on observation of versions currently in use on PyPI. Given a dump of
those version during PyCon 2009, 4287 of them:
- 2312 (53.93%) match NormalizedVersion without change
  with the automatic suggestion
- 3474 (81.04%) match when using this suggestion method

@param s {str} An irrational version string.
@returns A rational version string, or None, if couldn't determine one.

_suggest_semantic_version()

pip._vendor.distlib.version._suggest_semantic_version (   s )

protected

Try to suggest a semantic form for a version for which
_suggest_normalized_version couldn't come up with anything.

Variable Documentation

_REPLACEMENTS

tuple pip._vendor.distlib.version._REPLACEMENTS

protected

Initial value:

=  (
    (re.compile('[.+-]$'), ''),                     # remove trailing puncts
    (re.compile(r'^[.](\d)'), r'0.\1'),             # .N -> 0.N at start
    (re.compile('^[.-]'), ''),                      # remove leading puncts
    (re.compile(r'^\‍((.*)\‍)$'), r'\1'),             # remove parentheses
    (re.compile(r'^v(ersion)?\s*(\d+)'), r'\2'),    # remove leading v(ersion)
    (re.compile(r'^r(ev)?\s*(\d+)'), r'\2'),        # remove leading v(ersion)
    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
    (re.compile(r'\b(alfa|apha)\b'), 'alpha'),      # misspelt alpha
    (re.compile(r'\b(pre-alpha|prealpha)\b'),
        'pre.alpha'),                               # standardise
    (re.compile(r'\‍(beta\‍)$'), 'beta'),             # remove parentheses
)

_SCHEMES

dict pip._vendor.distlib.version._SCHEMES

protected

Initial value:

=  {
    'normalized': VersionScheme(_normalized_key, NormalizedMatcher,
                                _suggest_normalized_version),
    'legacy': VersionScheme(_legacy_key, LegacyMatcher, lambda self, s: s),
    'semantic': VersionScheme(_semantic_key, SemanticMatcher,
                              _suggest_semantic_version),
}

_SEMVER_RE

pip._vendor.distlib.version._SEMVER_RE

protected

Initial value:

=  re.compile(r'^(\d+)\.(\d+)\.(\d+)'
                        r'(-[a-z0-9]+(\.[a-z0-9-]+)*)?'
                        r'(\+[a-z0-9]+(\.[a-z0-9-]+)*)?$', re.I)

_SUFFIX_REPLACEMENTS

tuple pip._vendor.distlib.version._SUFFIX_REPLACEMENTS

protected

Initial value:

=  (
    (re.compile('^[:~._+-]+'), ''),                   # remove leading puncts
    (re.compile('[,*")([\\]]'), ''),                  # remove unwanted chars
    (re.compile('[~:+_ -]'), '.'),                    # replace illegal chars
    (re.compile('[.]{2,}'), '.'),                   # multiple runs of '.'
    (re.compile(r'\.$'), ''),                       # trailing '.'
)

_VERSION_REPLACE

dict pip._vendor.distlib.version._VERSION_REPLACE

protected

Initial value:

=  {
    'pre': 'c',
    'preview': 'c',
    '-': 'final-',
    'rc': 'c',
    'dev': '@',
    '': None,
    '.': None,
}

PEP440_VERSION_RE

pip._vendor.distlib.version.PEP440_VERSION_RE

Initial value:

=  re.compile(r'^v?(\d+!)?(\d+(\.\d+)*)((a|alpha|b|beta|c|rc|pre|preview)(\d+)?)?'
                               r'(\.(post|r|rev)(\d+)?)?([._-]?(dev)(\d+)?)?'
                               r'(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$', re.I)