EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / distutils / versionpredicate.py

"""Module for parsing and testing package version predicate strings.\r
"""\r
import re\r
import distutils.version\r
import operator\r
\r
\r
re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)")\r
# (package) (rest)\r
\r
re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses\r
re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")\r
# (comp) (version)\r
\r
\r
def splitUp(pred):\r
    """Parse a single version comparison.\r
\r
    Return (comparison string, StrictVersion)\r
    """\r
    res = re_splitComparison.match(pred)\r
    if not res:\r
        raise ValueError("bad package restriction syntax: %r" % pred)\r
    comp, verStr = res.groups()\r
    return (comp, distutils.version.StrictVersion(verStr))\r
\r
compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,\r
           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}\r
\r
class VersionPredicate:\r
    """Parse and test package version predicates.\r
\r
    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')\r
\r
    The `name` attribute provides the full dotted name that is given::\r
\r
    >>> v.name\r
    'pyepat.abc'\r
\r
    The str() of a `VersionPredicate` provides a normalized\r
    human-readable version of the expression::\r
\r
    >>> print v\r
    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)\r
\r
    The `satisfied_by()` method can be used to determine with a given\r
    version number is included in the set described by the version\r
    restrictions::\r
\r
    >>> v.satisfied_by('1.1')\r
    True\r
    >>> v.satisfied_by('1.4')\r
    True\r
    >>> v.satisfied_by('1.0')\r
    False\r
    >>> v.satisfied_by('4444.4')\r
    False\r
    >>> v.satisfied_by('1555.1b3')\r
    False\r
\r
    `VersionPredicate` is flexible in accepting extra whitespace::\r
\r
    >>> v = VersionPredicate(' pat( ==  0.1  )  ')\r
    >>> v.name\r
    'pat'\r
    >>> v.satisfied_by('0.1')\r
    True\r
    >>> v.satisfied_by('0.2')\r
    False\r
\r
    If any version numbers passed in do not conform to the\r
    restrictions of `StrictVersion`, a `ValueError` is raised::\r
\r
    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')\r
    Traceback (most recent call last):\r
      ...\r
    ValueError: invalid version number '1.2zb3'\r
\r
    It the module or package name given does not conform to what's\r
    allowed as a legal module or package name, `ValueError` is\r
    raised::\r
\r
    >>> v = VersionPredicate('foo-bar')\r
    Traceback (most recent call last):\r
      ...\r
    ValueError: expected parenthesized list: '-bar'\r
\r
    >>> v = VersionPredicate('foo bar (12.21)')\r
    Traceback (most recent call last):\r
      ...\r
    ValueError: expected parenthesized list: 'bar (12.21)'\r
\r
    """\r
\r
    def __init__(self, versionPredicateStr):\r
        """Parse a version predicate string.\r
        """\r
        # Fields:\r
        #    name:  package name\r
        #    pred:  list of (comparison string, StrictVersion)\r
\r
        versionPredicateStr = versionPredicateStr.strip()\r
        if not versionPredicateStr:\r
            raise ValueError("empty package restriction")\r
        match = re_validPackage.match(versionPredicateStr)\r
        if not match:\r
            raise ValueError("bad package name in %r" % versionPredicateStr)\r
        self.name, paren = match.groups()\r
        paren = paren.strip()\r
        if paren:\r
            match = re_paren.match(paren)\r
            if not match:\r
                raise ValueError("expected parenthesized list: %r" % paren)\r
            str = match.groups()[0]\r
            self.pred = [splitUp(aPred) for aPred in str.split(",")]\r
            if not self.pred:\r
                raise ValueError("empty parenthesized list in %r"\r
                                 % versionPredicateStr)\r
        else:\r
            self.pred = []\r
\r
    def __str__(self):\r
        if self.pred:\r
            seq = [cond + " " + str(ver) for cond, ver in self.pred]\r
            return self.name + " (" + ", ".join(seq) + ")"\r
        else:\r
            return self.name\r
\r
    def satisfied_by(self, version):\r
        """True if version is compatible with all the predicates in self.\r
        The parameter version must be acceptable to the StrictVersion\r
        constructor.  It may be either a string or StrictVersion.\r
        """\r
        for cond, ver in self.pred:\r
            if not compmap[cond](version, ver):\r
                return False\r
        return True\r
\r
\r
_provision_rx = None\r
\r
def split_provision(value):\r
    """Return the name and optional version number of a provision.\r
\r
    The version number, if given, will be returned as a `StrictVersion`\r
    instance, otherwise it will be `None`.\r
\r
    >>> split_provision('mypkg')\r
    ('mypkg', None)\r
    >>> split_provision(' mypkg( 1.2 ) ')\r
    ('mypkg', StrictVersion ('1.2'))\r
    """\r
    global _provision_rx\r
    if _provision_rx is None:\r
        _provision_rx = re.compile(\r
            "([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$")\r
    value = value.strip()\r
    m = _provision_rx.match(value)\r
    if not m:\r
        raise ValueError("illegal provides specification: %r" % value)\r
    ver = m.group(2) or None\r
    if ver:\r
        ver = distutils.version.StrictVersion(ver)\r
    return m.group(1), ver\r