Upgrade packaging lib to 15.0

3 files changed, 74 insertions, 11 deletions

diff --git a/pkg_resources/_vendor/packaging/__about__.py b/pkg_resources/_vendor/packaging/__about__.py
index d3e50f1e..36f1a35c 100644
--- a/pkg_resources/_vendor/packaging/__about__.py
+++ b/pkg_resources/_vendor/packaging/__about__.py
@@ -22,7 +22,7 @@ __title__ = "packaging"
 __summary__ = "Core utilities for Python packages"
 __uri__ = "https://github.com/pypa/packaging"
 
-__version__ = "14.5"
+__version__ = "15.0"
 
 __author__ = "Donald Stufft"
 __email__ = "donald@stufft.io"
diff --git a/pkg_resources/_vendor/packaging/specifiers.py b/pkg_resources/_vendor/packaging/specifiers.py
index 80225786..9ad0a635 100644
--- a/pkg_resources/_vendor/packaging/specifiers.py
+++ b/pkg_resources/_vendor/packaging/specifiers.py
@@ -458,21 +458,59 @@ class Specifier(_IndividualSpecifier):
 
     @_require_version_compare
     def _compare_less_than(self, prospective, spec):
-        # Less than are defined as exclusive operators, this implies that
-        # pre-releases do not match for the same series as the spec. This is
-        # implemented by making <V imply !=V.*.
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
         spec = Version(spec)
-        return (prospective < spec
-                and self._get_operator("!=")(prospective, str(spec) + ".*"))
+
+        # Check to see if the prospective version is less than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective < spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a pre-release version, that we do not accept pre-release
+        # versions for the version mentioned in the specifier (e.g. <3.1 should
+        # not match 3.1.dev0, but should match 3.0.dev0).
+        if not spec.is_prerelease and prospective.is_prerelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # less than the spec version *and* it's not a pre-release of the same
+        # version in the spec.
+        return True
 
     @_require_version_compare
     def _compare_greater_than(self, prospective, spec):
-        # Greater than are defined as exclusive operators, this implies that
-        # pre-releases do not match for the same series as the spec. This is
-        # implemented by making >V imply !=V.*.
+        # Convert our spec to a Version instance, since we'll want to work with
+        # it as a version.
         spec = Version(spec)
-        return (prospective > spec
-                and self._get_operator("!=")(prospective, str(spec) + ".*"))
+
+        # Check to see if the prospective version is greater than the spec
+        # version. If it's not we can short circuit and just return False now
+        # instead of doing extra unneeded work.
+        if not prospective > spec:
+            return False
+
+        # This special case is here so that, unless the specifier itself
+        # includes is a post-release version, that we do not accept
+        # post-release versions for the version mentioned in the specifier
+        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
+        if not spec.is_postrelease and prospective.is_postrelease:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # Ensure that we do not allow a local version of the version mentioned
+        # in the specifier, which is techincally greater than, to match.
+        if prospective.local is not None:
+            if Version(prospective.base_version) == Version(spec.base_version):
+                return False
+
+        # If we've gotten to here, it means that prospective version is both
+        # greater than the spec version *and* it's not a pre-release of the
+        # same version in the spec.
+        return True
 
     def _compare_arbitrary(self, prospective, spec):
         return str(prospective).lower() == str(spec).lower()
diff --git a/pkg_resources/_vendor/packaging/version.py b/pkg_resources/_vendor/packaging/version.py
index 8d779a48..cf8afb16 100644
--- a/pkg_resources/_vendor/packaging/version.py
+++ b/pkg_resources/_vendor/packaging/version.py
@@ -96,6 +96,10 @@ class LegacyVersion(_BaseVersion):
         return self._version
 
     @property
+    def base_version(self):
+        return self._version
+
+    @property
     def local(self):
         return None
 
@@ -103,6 +107,10 @@ class LegacyVersion(_BaseVersion):
     def is_prerelease(self):
         return False
 
+    @property
+    def is_postrelease(self):
+        return False
+
 
 _legacy_version_component_re = re.compile(
     r"(\d+ | [a-z]+ | \.| -)", re.VERBOSE,
@@ -270,6 +278,19 @@ class Version(_BaseVersion):
         return str(self).split("+", 1)[0]
 
     @property
+    def base_version(self):
+        parts = []
+
+        # Epoch
+        if self._version.epoch != 0:
+            parts.append("{0}!".format(self._version.epoch))
+
+        # Release segment
+        parts.append(".".join(str(x) for x in self._version.release))
+
+        return "".join(parts)
+
+    @property
     def local(self):
         version_string = str(self)
         if "+" in version_string:
@@ -279,6 +300,10 @@ class Version(_BaseVersion):
     def is_prerelease(self):
         return bool(self._version.dev or self._version.pre)
 
+    @property
+    def is_postrelease(self):
+        return bool(self._version.post)
+
 
 def _parse_letter_version(letter, number):
     if letter: