remove setuptools, closes #234

pyup/package.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import, print_function, unicode_literals
-from pkg_resources import parse_version
+from packaging.version import parse as parse_version
 import requests
 
 

pyup/requirements.py

@@ -1,7 +1,6 @@
 from __future__ import unicode_literals
-from pkg_resources import parse_requirements
-from pkg_resources import parse_version
-from pkg_resources._vendor.packaging.specifiers import SpecifierSet
+from packaging.version import parse as parse_version
+from packaging.specifiers import SpecifierSet
 import hashin
 from .updates import InitialUpdate, SequentialUpdate, ScheduledUpdate
 from .pullrequest import PullRequest
@@ -10,6 +9,7 @@
 
 from dparse import parse, parser, updater, filetypes
 from dparse.dependencies import Dependency
+from dparse.parser import setuptools_parse_requirements_backport as parse_requirements
 
 PYTHON_VERSIONS = [
     "2.7", "3.0", "3.1", "3.2", "3.3", "3.4", "3.5", "3.6"
@@ -195,31 +195,34 @@ def __ne__(self, other):
     def __str__(self):
         return "Requirement.parse({line}, {lineno})".format(line=self.line, lineno=self.lineno)
 
+    def __repr__(self):
+        return self.__str__()
+
     @property
     def is_pinned(self):
-        if len(self.specs) == 1 and self.specs[0][0] == "==":
+        if len(self.specs._specs) == 1 and next(iter(self.specs._specs))._spec[0] == "==":
             return True
         return False
 
     @property
     def is_compatible(self):
-        if len(self.specs) == 1 and self.specs[0][0] == "~=":
+        if len(self.specs._specs) == 1 and next(iter(self.specs._specs))._spec[0] == "~=":
             return True
         return False
 
     @property
     def is_open_ranged(self):
-        if len(self.specs) == 1 and self.specs[0][0] == ">=":
+        if len(self.specs._specs) == 1 and next(iter(self.specs._specs))._spec[0] == ">=":
             return True
         return False
 
     @property
     def is_ranged(self):
-        return len(self.specs) >= 1 and not self.is_pinned
+        return len(self.specs._specs) >= 1 and not self.is_pinned
 
     @property
     def is_loose(self):
-        return len(self.specs) == 0
+        return len(self.specs._specs) == 0
 
     @property
     def filter(self):
@@ -231,20 +234,22 @@ def filter(self):
         if rqfilter:
             try:
                 rqfilter, = parse_requirements("filter " + rqfilter)
-                if len(rqfilter.specs) > 0:
-                    return rqfilter.specs
+                if len(rqfilter.specifier._specs) > 0:
+                    return rqfilter.specifier
             except ValueError:
                 pass
         return False
 
     @property
     def version(self):
         if self.is_pinned or self.is_compatible:
-            return self.specs[0][1]
+            return next(iter(self.specs._specs))._spec[1]
 
         specs = self.specs
         if self.filter:
-            specs += self.filter
+            specs = SpecifierSet(
+                ",".join(["".join(s._spec) for s in list(specs._specs) + list(self.filter._specs)])
+            )
         return self.get_latest_version_within_specs(
             specs,
             versions=self.package.versions,
@@ -267,13 +272,14 @@ def latest_version(self):
 
     @property
     def prereleases(self):
-        return self.is_pinned and parse_version(self.specs[0][1]).is_prerelease
+        return self.is_pinned and parse_version(
+            next(iter(self.specs._specs))._spec[1]).is_prerelease
 
     @staticmethod
     def get_latest_version_within_specs(specs, versions, prereleases=None):
         # build up a spec set and convert compatible specs to pinned ones
         spec_set = SpecifierSet(
-            ",".join(["".join([x.replace("~=", "=="), y]) for x, y in specs])
+            ",".join(["".join(s._spec).replace("~=", "==") for s in specs])
         )
         candidates = []
         for version in versions:
@@ -363,8 +369,8 @@ def parse(cls, s, lineno, file_type=filetypes.requirements_txt):
         else:
             parsed, = parse_requirements(s)
         return cls(
-            name=parsed.project_name,
-            specs=parsed.specs,
+            name=parsed.name,
+            specs=parsed.specifier,
             line=s,
             lineno=lineno,
             extras=parsed.extras,

setup.py

@@ -23,9 +23,8 @@
     "hashin-pyup",
     "packaging",
     "six",
-    "setuptools<=26.1.1",
     "python-gitlab",
-    "dparse"
+    "dparse>=0.2.1"
 ]
 
 test_requirements = [

tests/test_requirements.py

@@ -477,20 +477,21 @@ def test_not_equals(self):
         )
 
     def test_filter(self):
+        from packaging.specifiers import SpecifierSet
         r = Requirement.parse("Django==1.7.6", 0)
         self.assertEqual(r.filter, False)
 
         r = Requirement.parse("Django==1.7.6 # pyup: < 1.7.8", 0)
-        self.assertEqual(r.filter, [("<", "1.7.8")])
+        self.assertEqual(r.filter, SpecifierSet("<1.7.8"))
 
         req = Requirement.parse("some-package==1.9.3 # rq.filter: <1.10 #some comment here", 0)
-        self.assertEqual(req.filter, [("<", "1.10")])
+        self.assertEqual(req.filter, SpecifierSet("<1.10"))
 
         r = Requirement.parse("django==1.7.1  # pyup: <1.7.6", 0)
 
         r = Requirement.parse("Django==1.7.6 # pyup: < 1.7.8, > 1.7.2", 0)
         self.assertEqual(
-            sorted(r.filter, key=lambda r: r[1]),
+            sorted([s._spec for s in r.filter._specs], key=lambda r: r[1]),
             sorted([("<", "1.7.8"), (">", "1.7.2")], key=lambda r: r[1])
         )
 
@@ -575,12 +576,12 @@ def test_package_filter_present(self):
 
         req = Requirement.parse("Django #rq.filter: >=1.4,<1.5", 0)
         self.assertEqual(
-            sorted(req.filter, key=lambda i: i[0]),
+            sorted([s._spec for s in req.filter._specs], key=lambda i: i[0]),
             sorted([('>=', '1.4'), ('<', '1.5')], key=lambda i: i[0])
         )
 
         req = Requirement.parse("Django #rq.filter:!=1.2", 0)
-        self.assertEqual(req.filter, [('!=', '1.2')])
+        self.assertEqual([s._spec for s in req.filter._specs], [('!=', '1.2')])
 
         req = Requirement.parse("Django #rq.filter:foo", 0)
         self.assertEqual(req.filter, False)
@@ -596,13 +597,13 @@ def test_package_filter_present(self):
 
         req = Requirement.parse("Django #pyup: >=1.4,<1.5", 0)
         self.assertEqual(
-            sorted(req.filter, key=lambda i: i[0]),
+            sorted([s._spec for s in req.filter._specs], key=lambda i: i[0]),
             sorted([('>=', '1.4'), ('<', '1.5')], key=lambda i: i[0])
         )
 
 
         req = Requirement.parse("Django #pyup:!=1.2", 0)
-        self.assertEqual(req.filter, [('!=', '1.2')])
+        self.assertEqual([s._spec for s in req.filter._specs], [('!=', '1.2')])
 
         req = Requirement.parse("Django #pyup:foo", 0)
         self.assertEqual(req.filter, False)
@@ -612,15 +613,16 @@ def test_package_filter_present(self):
 
 
     def test_get_latest_version_within_specs(self):
+        from packaging.specifiers import SpecifierSet
         latest = Requirement.get_latest_version_within_specs(
-            (("==", "1.2"), ("!=", "1.2")),
+            SpecifierSet("==1.2,!=1.2"),
             ["1.2", "1.3", "1.4", "1.5"]
         )
 
         self.assertEqual(latest, None)
 
         latest = Requirement.get_latest_version_within_specs(
-            (("==", "1.2.1"),),
+            SpecifierSet("==1.2.1"),
             ["1.2.0", "1.2.1", "1.2.2", "1.3"]
         )
 
@@ -667,6 +669,7 @@ def test_version_unpinned(self):
             r = Requirement.parse("django", 0)
             self.assertEqual(r.version, "1.9.1")
 
+        print("FILTER TEST")
         with patch('pyup.requirements.Requirement.package', new_callable=PropertyMock,
                    return_value=package_factory(
                        name="django",