Fix error with pip 9.0.2 and change how wildcard constraints are handled

CHANGELOG.md

 # Change Log
 
+[Unreleased]
+
+### Changed
+
+- Changed how wilcard constraints are handled.
+
+### Fixed
+
+- Fixed errors with pip 9.0.2.
+
+
 ## [0.6.1] - 2018-02-18
 
 ### Fixed

poetry/locations.py

-# -*- coding: utf-8 -*-
-
-from pip.utils.appdirs import user_cache_dir, user_config_dir
+from .utils.appdirs import user_cache_dir
+from .utils.appdirs import user_config_dir
 
 
 CACHE_DIR = user_cache_dir('pypoetry')

poetry/packages/__init__.py

+import os
+import re
+
+from poetry.semver.version_parser import VersionParser
+from poetry.version.markers import Marker
+from poetry.version.requirements import Requirement
+
 from .dependency import Dependency
 from .locker import Locker
 from .package import Package
+from .utils.link import Link
+from .utils.utils import convert_markers
+from .utils.utils import group_markers
+from .utils.utils import is_archive_file
+from .utils.utils import is_installable_dir
+from .utils.utils import is_url
+from .utils.utils import path_to_url
+from .utils.utils import strip_extras
 from .vcs_dependency import VCSDependency
+
+
+def dependency_from_pep_508(name):
+    req = Requirement(name)
+
+    if req.marker:
+        markers = convert_markers(req.marker.markers)
+    else:
+        markers = {}
+
+    name = req.name
+    path = os.path.normpath(os.path.abspath(name))
+    link = None
+
+    if is_url(name):
+        link = Link(name)
+    else:
+        p, extras = strip_extras(path)
+        if (os.path.isdir(p) and
+                (os.path.sep in name or name.startswith('.'))):
+
+            if not is_installable_dir(p):
+                raise ValueError(
+                    "Directory %r is not installable. File 'setup.py' "
+                    "not found." % name
+                )
+            link = Link(path_to_url(p))
+        elif is_archive_file(p):
+            link = Link(path_to_url(p))
+
+    # it's a local file, dir, or url
+    if link:
+        # Handle relative file URLs
+        if link.scheme == 'file' and re.search(r'\.\./', link.url):
+            link = Link(
+                path_to_url(os.path.normpath(os.path.abspath(link.path)))
+            )
+        # wheel file
+        if link.is_wheel:
+            m = re.match(
+                '^(?P<namever>(?P<name>.+?)-(?P<ver>\d.*?))',
+                link.filename
+            )
+            if not m:
+                raise ValueError(f'Invalid wheel name: {link.filename}')
+
+            name = m.group('name')
+            version = m.group('ver')
+            dep = Dependency(name, version)
+        else:
+            name = link.egg_fragment
+
+            if link.scheme == 'git':
+                dep = VCSDependency(name, 'git', link.url_without_fragment)
+            else:
+                dep = Dependency(name, '*')
+    else:
+        if req.pretty_constraint:
+            constraint = req.constraint
+        else:
+            constraint = '*'
+
+        dep = Dependency(name, constraint)
+
+    if 'extra' in markers:
+        # If we have extras, the dependency is optional
+        dep.deactivate()
+
+        for or_ in markers['extra']:
+            for _, extra in or_:
+                dep.extras.append(extra)
+
+    if 'python_version' in markers:
+        ors = []
+        for or_ in markers['python_version']:
+            ands = []
+            for op, version in or_:
+                # Expand python version
+                if op == '==':
+                    version = '~' + version
+                    op = ''
+                elif op == '!=':
+                    version += '.*'
+
+                ands.append(f'{op}{version}')
+
+            ors.append(' '.join(ands))
+
+        dep.python_versions = ' || '.join(ors)
+
+    if 'sys_platform' in markers:
+        ors = []
+        for or_ in markers['sys_platform']:
+            ands = []
+            for op, platform in or_:
+                if op == '==':
+                    op = ''
+
+                ands.append(f'{op}{platform}')
+
+            ors.append(' '.join(ands))
+
+        dep.platform = ' || '.join(ors)
+
+    return dep

poetry/packages/dependency.py

@@ -3,6 +3,7 @@ import poetry.packages
 from poetry.semver.constraints import Constraint
 from poetry.semver.constraints import EmptyConstraint
 from poetry.semver.constraints import MultiConstraint
+from poetry.semver.constraints.base_constraint import BaseConstraint
 from poetry.semver.version_parser import VersionParser
 
 from .constraints.platform_constraint import PlatformConstraint
@@ -21,7 +22,10 @@ class Dependency:
         self._parser = VersionParser()
 
         try:
-            self._constraint = self._parser.parse_constraints(constraint)
+            if not isinstance(constraint, BaseConstraint):
+                self._constraint = self._parser.parse_constraints(constraint)
+            else:
+                self._constraint = constraint
         except ValueError:
             self._constraint = self._parser.parse_constraints('*')
 
@@ -130,6 +134,10 @@ class Dependency:
 
         return requirement
 
+    @classmethod
+    def from_pep_508(cls):
+        return
+
     def _create_nested_marker(self, name, constraint):
         if isinstance(constraint, MultiConstraint):
             parts = []

poetry/packages/utils/link.py

+import posixpath
+import urllib.parse
+import urllib.request
+import re
+
+from .utils import path_to_url
+from .utils import splitext
+
+
+class Link:
+
+    def __init__(self, url, comes_from=None, requires_python=None):
+        """
+        Object representing a parsed link from https://pypi.python.org/simple/*
+
+        url:
+            url of the resource pointed to (href of the link)
+        comes_from:
+            instance of HTMLPage where the link was found, or string.
+        requires_python:
+            String containing the `Requires-Python` metadata field, specified
+            in PEP 345. This may be specified by a data-requires-python
+            attribute in the HTML link tag, as described in PEP 503.
+        """
+
+        # url can be a UNC windows share
+        if url.startswith('\\\\'):
+            url = path_to_url(url)
+
+        self.url = url
+        self.comes_from = comes_from
+        self.requires_python = requires_python if requires_python else None
+
+    def __str__(self):
+        if self.requires_python:
+            rp = ' (requires-python:%s)' % self.requires_python
+        else:
+            rp = ''
+        if self.comes_from:
+            return '%s (from %s)%s' % (self.url, self.comes_from, rp)
+        else:
+            return str(self.url)
+
+    def __repr__(self):
+        return '<Link %s>' % self
+
+    def __eq__(self, other):
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url == other.url
+
+    def __ne__(self, other):
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url != other.url
+
+    def __lt__(self, other):
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url < other.url
+
+    def __le__(self, other):
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url <= other.url
+
+    def __gt__(self, other):
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url > other.url
+
+    def __ge__(self, other):
+        if not isinstance(other, Link):
+            return NotImplemented
+        return self.url >= other.url
+
+    def __hash__(self):
+        return hash(self.url)
+
+    @property
+    def filename(self):
+        _, netloc, path, _, _ = urllib.parse.urlsplit(self.url)
+        name = posixpath.basename(path.rstrip('/')) or netloc
+        name = urllib.parse.unquote(name)
+        assert name, ('URL %r produced no filename' % self.url)
+        return name
+
+    @property
+    def scheme(self):
+        return urllib.parse.urlsplit(self.url)[0]
+
+    @property
+    def netloc(self):
+        return urllib.parse.urlsplit(self.url)[1]
+
+    @property
+    def path(self):
+        return urllib.parse.unquote(urllib.parse.urlsplit(self.url)[2])
+
+    def splitext(self):
+        return splitext(posixpath.basename(self.path.rstrip('/')))
+
+    @property
+    def ext(self):
+        return self.splitext()[1]
+
+    @property
+    def url_without_fragment(self):
+        scheme, netloc, path, query, fragment = urllib.parse.urlsplit(self.url)
+        return urllib.parse.urlunsplit((scheme, netloc, path, query, None))
+
+    _egg_fragment_re = re.compile(r'[#&]egg=([^&]*)')
+
+    @property
+    def egg_fragment(self):
+        match = self._egg_fragment_re.search(self.url)
+        if not match:
+            return None
+        return match.group(1)
+
+    _subdirectory_fragment_re = re.compile(r'[#&]subdirectory=([^&]*)')
+
+    @property
+    def subdirectory_fragment(self):
+        match = self._subdirectory_fragment_re.search(self.url)
+        if not match:
+            return None
+        return match.group(1)
+
+    _hash_re = re.compile(
+        r'(sha1|sha224|sha384|sha256|sha512|md5)=([a-f0-9]+)'
+    )
+
+    @property
+    def hash(self):
+        match = self._hash_re.search(self.url)
+        if match:
+            return match.group(2)
+        return None
+
+    @property
+    def hash_name(self):
+        match = self._hash_re.search(self.url)
+        if match:
+            return match.group(1)
+        return None
+
+    @property
+    def show_url(self):
+        return posixpath.basename(self.url.split('#', 1)[0].split('?', 1)[0])
+
+    @property
+    def is_wheel(self):
+        return self.ext == '.whl'
+
+    @property
+    def is_artifact(self):
+        """
+        Determines if this points to an actual artifact (e.g. a tarball) or if
+        it points to an "abstract" thing like a path or a VCS location.
+        """
+        if self.scheme in ['ssh', 'git', 'hg', 'bzr', 'sftp', 'svn']:
+            return False
+
+        return True

poetry/packages/utils/utils.py

+import os
+import posixpath
+import re
+import urllib.parse
+import urllib.request
+
+
+BZ2_EXTENSIONS = ('.tar.bz2', '.tbz')
+XZ_EXTENSIONS = ('.tar.xz', '.txz', '.tlz', '.tar.lz', '.tar.lzma')
+ZIP_EXTENSIONS = ('.zip', '.whl')
+TAR_EXTENSIONS = ('.tar.gz', '.tgz', '.tar')
+ARCHIVE_EXTENSIONS = (
+    ZIP_EXTENSIONS + BZ2_EXTENSIONS + TAR_EXTENSIONS + XZ_EXTENSIONS)
+SUPPORTED_EXTENSIONS = ZIP_EXTENSIONS + TAR_EXTENSIONS
+
+try:
+    import bz2  # noqa
+    SUPPORTED_EXTENSIONS += BZ2_EXTENSIONS
+except ImportError:
+    pass
+
+try:
+    # Only for Python 3.3+
+    import lzma  # noqa
+    SUPPORTED_EXTENSIONS += XZ_EXTENSIONS
+except ImportError:
+    pass
+
+
+def path_to_url(path):
+    """
+    Convert a path to a file: URL.  The path will be made absolute and have
+    quoted path parts.
+    """
+    path = os.path.normpath(os.path.abspath(path))
+    url = urllib.parse.urljoin('file:', urllib.request.pathname2url(path))
+    return url
+
+
+def is_url(name):
+    if ':' not in name:
+        return False
+    scheme = name.split(':', 1)[0].lower()
+
+    return scheme in [
+        'http', 'https',
+        'file',
+        'ftp',
+        'ssh', 'git', 'hg', 'bzr', 'sftp', 'svn'
+        'ssh'
+    ]
+
+
+def strip_extras(path):
+    m = re.match(r'^(.+)(\[[^\]]+\])$', path)
+    extras = None
+    if m:
+        path_no_extras = m.group(1)
+        extras = m.group(2)
+    else:
+        path_no_extras = path
+
+    return path_no_extras, extras
+
+
+def is_installable_dir(path):
+    """Return True if `path` is a directory containing a setup.py file."""
+    if not os.path.isdir(path):
+        return False
+    setup_py = os.path.join(path, 'setup.py')
+    if os.path.isfile(setup_py):
+        return True
+    return False
+
+
+def is_archive_file(name):
+    """Return True if `name` is a considered as an archive file."""
+    ext = splitext(name)[1].lower()
+    if ext in ARCHIVE_EXTENSIONS:
+        return True
+    return False
+
+
+def splitext(path):
+    """Like os.path.splitext, but take off .tar too"""
+    base, ext = posixpath.splitext(path)
+    if base.lower().endswith('.tar'):
+        ext = base[-4:] + ext
+        base = base[:-4]
+    return base, ext
+
+
+def group_markers(markers):
+    groups = [[]]
+
+    for marker in markers:
+        assert isinstance(marker, (list, tuple, str))
+
+        if isinstance(marker, list):
+            groups[-1].append(group_markers(marker))
+        elif isinstance(marker, tuple):
+            lhs, op, rhs = marker
+
+            groups[-1].append((lhs.value, op, rhs.value))
+        else:
+            assert marker in ["and", "or"]
+            if marker == "or":
+                groups.append([])
+
+    return groups
+
+
+def convert_markers(markers):
+    groups = group_markers(markers)
+
+    requirements = {}
+
+    def _group(_groups, or_=False):
+        nonlocal requirements
+
+        for group in _groups:
+            if isinstance(group, tuple):
+                variable, op, value = group
+                group_name = str(variable)
+                if group_name not in requirements:
+                    requirements[group_name] = [[]]
+                elif or_:
+                    requirements[group_name].append([])
+
+                or_ = False
+
+                requirements[group_name][-1].append((str(op), str(value)))
+            else:
+                _group(group, or_=True)
+
+    _group(groups)
+
+    return requirements
+

poetry/repositories/legacy_repository.py

-import re
-
 from pathlib import Path
 from piptools.cache import DependencyCache
 from piptools.repositories import PyPIRepository
 from piptools.resolver import Resolver
 from piptools.scripts.compile import get_pip_command
-from pip.req import InstallRequirement
-from pip.exceptions import InstallationError
 
 from cachy import CacheManager
 
 import poetry.packages
 
 from poetry.locations import CACHE_DIR
+from poetry.packages import dependency_from_pep_508
 from poetry.semver.constraints import Constraint
 from poetry.semver.constraints.base_constraint import BaseConstraint
 from poetry.semver.version_parser import VersionParser
+from poetry.version.markers import InvalidMarker
 
 from .pypi_repository import PyPiRepository
 
@@ -111,56 +109,23 @@ class LegacyRepository(PyPiRepository):
             release_info = self.get_release_info(name, version)
             package = poetry.packages.Package(name, version, version)
             for req in release_info['requires_dist']:
-                req = InstallRequirement.from_line(req)
-
-                name = req.name
-                version = str(req.req.specifier)
-
-                dependency = Dependency(
-                    name,
-                    version,
-                    optional=req.markers
-                )
-
-                is_extra = False
-                if req.markers:
-                    # Setting extra dependencies and requirements
-                    requirements = self._convert_markers(
-                        req.markers._markers
-                    )
-
-                    if 'python_version' in requirements:
-                        ors = []
-                        for or_ in requirements['python_version']:
-                            ands = []
-                            for op, version in or_:
-                                ands.append(f'{op}{version}')
+                try:
+                    dependency = dependency_from_pep_508(req)
+                except InvalidMarker:
+                    # Invalid marker
+                    # We strip the markers hoping for the best
+                    req = req.split(';')[0]
 
-                            ors.append(' '.join(ands))
+                    dependency = dependency_from_pep_508(req)
 
-                        dependency.python_versions = ' || '.join(ors)
+                if dependency.extras:
+                    for extra in dependency.extras:
+                        if extra not in package.extras:
+                            package.extras[extra] = []
 
-                    if 'sys_platform' in requirements:
-                        ors = []
-                        for or_ in requirements['sys_platform']:
-                            ands = []
-                            for op, platform in or_:
-                                ands.append(f'{op}{platform}')
+                        package.extras[extra].append(dependency)
 
-                            ors.append(' '.join(ands))
-
-                        dependency.platform = ' || '.join(ors)
-
-                    if 'extra' in requirements:
-                        is_extra = True
-                        for _extras in requirements['extra']:
-                            for _, extra in _extras:
-                                if extra not in package.extras:
-                                    package.extras[extra] = []
-
-                                package.extras[extra].append(dependency)
-
-                if not is_extra:
+                if not dependency.is_optional():
                     package.requires.append(dependency)
 
             # Adding description
@@ -194,6 +159,9 @@ class LegacyRepository(PyPiRepository):
         )
 
     def _get_release_info(self, name: str, version: str) -> dict:
+        from pip.req import InstallRequirement
+        from pip.exceptions import InstallationError
+
         ireq = InstallRequirement.from_line(f'{name}=={version}')
         resolver = Resolver(
             [ireq], self._repository,

poetry/repositories/pypi_repository.py

 from pathlib import Path
-from pip.req import InstallRequirement
 from typing import List
 from typing import Union
 
@@ -7,11 +6,12 @@ from cachy import CacheManager
 from requests import get
 
 from poetry.locations import CACHE_DIR
-from poetry.packages import Dependency
+from poetry.packages import dependency_from_pep_508
 from poetry.packages import Package
 from poetry.semver.constraints import Constraint
 from poetry.semver.constraints.base_constraint import BaseConstraint
 from poetry.semver.version_parser import VersionParser
+from poetry.version.markers import InvalidMarker
 
 from .repository import Repository
 
@@ -86,61 +86,20 @@ class PyPiRepository(Repository):
             requires_dist = release_info['requires_dist'] or []
             for req in requires_dist:
                 try:
-                    req = InstallRequirement.from_line(req)
-                except Exception:
-                    # Probably an invalid marker
+                    dependency = dependency_from_pep_508(req)
+                except InvalidMarker:
+                    # Invalid marker
                     # We strip the markers hoping for the best
                     req = req.split(';')[0]
 
-                    req = InstallRequirement.from_line(req)
+                    dependency = dependency_from_pep_508(req)
 
-                name = req.name
-                version = str(req.req.specifier)
+                if dependency.extras:
+                    for extra in dependency.extras:
+                        if extra not in package.extras:
+                            package.extras[extra] = []
 
-                dependency = Dependency(
-                    name,
-                    version
-                )
-
-                if req.markers:
-                    # Setting extra dependencies and requirements
-                    requirements = self._convert_markers(
-                        req.markers._markers
-                    )
-
-                    if 'python_version' in requirements:
-                        ors = []
-                        for or_ in requirements['python_version']:
-                            ands = []
-                            for op, version in or_:
-                                ands.append(f'{op}{version}')
-
-                            ors.append(' '.join(ands))
-
-                        dependency.python_versions = ' || '.join(ors)
-
-                    if 'sys_platform' in requirements:
-                        ors = []
-                        for or_ in requirements['sys_platform']:
-                            ands = []
-                            for op, platform in or_:
-                                if op == '==':
-                                    op = ''
-
-                                ands.append(f'{op}{platform}')
-
-                            ors.append(' '.join(ands))
-
-                        dependency.platform = ' || '.join(ors)
-
-                    if 'extra' in requirements:
-                        dependency.deactivate()
-                        for _extras in requirements['extra']:
-                            for _, extra in _extras:
-                                if extra not in package.extras:
-                                    package.extras[extra] = []
-
-                                package.extras[extra].append(dependency)
+                        package.extras[extra].append(dependency)
 
                 if not dependency.is_optional():
                     package.requires.append(dependency)
@@ -250,47 +209,3 @@ class PyPiRepository(Repository):
         json_data = json_response.json()
 
         return json_data
-
-    def _group_markers(self, markers):
-        groups = [[]]
-
-        for marker in markers:
-            assert isinstance(marker, (list, tuple, str))
-
-            if isinstance(marker, list):
-                groups[-1].append(self._group_markers(marker))
-            elif isinstance(marker, tuple):
-                lhs, op, rhs = marker
-
-                groups[-1].append((lhs.value, op, rhs.value))
-            else:
-                assert marker in ["and", "or"]
-                if marker == "or":
-                    groups.append([])
-
-        return groups
-
-    def _convert_markers(self, markers):
-        groups = self._group_markers(markers)[0]
-
-        requirements = {}
-
-        def _group(_groups, or_=False):
-            nonlocal requirements
-
-            for group in _groups:
-                if isinstance(group, tuple):
-                    variable, op, value = group
-                    group_name = str(variable)
-                    if group_name not in requirements:
-                        requirements[group_name] = [[]]
-                    elif or_:
-                        requirements[group_name].append([])
-
-                    requirements[group_name][-1].append((str(op), str(value)))
-                else:
-                    _group(group, or_=True)
-
-        _group(groups)
-
-        return requirements

poetry/semver/constraints/constraint.py

@@ -36,7 +36,7 @@ class Constraint(BaseConstraint):
     }
 
     def __init__(self, operator: str, version: str):
-        if operator not in self._trans_op_str:
+        if operator not in self.supported_operators:
             raise ValueError(
                 f'Invalid operator "{operator}" given, '
                 f'expected one of: {", ".join(self.supported_operators)}'
@@ -63,7 +63,10 @@ class Constraint(BaseConstraint):
         return self._version
 
     def matches(self, provider):
-        if isinstance(provider, self.__class__):
+        if (
+            isinstance(provider, self.__class__)
+            and provider.__class__ is self.__class__
+        ):
             return self.match_specific(provider)
 
         # turn matching around to find a match

poetry/semver/constraints/wildcard_constraint.py

+import re
+
+from .constraint import Constraint
+
+
+class WilcardConstraint(Constraint):
+
+    def __init__(self, constraint: str):
+        m = re.match(
+            '^(!=|==)?v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.[xX*])+$',
+            constraint
+        )
+        if not m:
+            raise ValueError('Invalid value for wildcard constraint')
+
+        if not m.group(1):
+            operator = '=='
+        else:
+            operator = m.group(1)
+
+        super().__init__(
+            operator,
+            '.'.join([g if g else '*' for g in m.groups()[1:]])
+        )
+
+        if m.group(4):
+            position = 2
+        elif m.group(3):
+            position = 1
+        else:
+            position = 0
+
+        from ..version_parser import VersionParser
+
+        parser = VersionParser()
+        groups = m.groups()[1:]
+        low_version = parser._manipulate_version_string(
+            groups, position
+        )
+        high_version = parser._manipulate_version_string(
+            groups, position, 1
+        )
+
+        if operator == '!=':
+            if low_version == '0.0.0.0':
+                self._constraint = Constraint('>=', high_version)
+            else:
+                self._constraint = parser.parse_constraints(
+                    f'<{low_version} || >={high_version}'
+                )
+        else:
+            if low_version == '0.0.0.0':
+                self._constraint = Constraint('<', high_version)
+            else:
+                self._constraint = parser.parse_constraints(
+                    f'>={low_version},<{high_version}'
+                )
+
+    @property
+    def supported_operators(self):
+        return ['!=', '==']
+
+    @property
+    def constraint(self):
+        return self._constraint
+
+    def matches(self, provider) -> bool:
+        if isinstance(provider, self.__class__):
+            return self._constraint.matches(provider.constraint)
+
+        return provider.matches(self._constraint)
+
+    def __str__(self):
+        op = ''
+        if self.string_operator == '!=':
+            op = '!= '
+
+        return '{}{}'.format(
+            op,
+            self._version
+        )

poetry/semver/version_parser.py

@@ -3,6 +3,7 @@ import re
 from .constraints.constraint import Constraint
 from .constraints.empty_constraint import EmptyConstraint
 from .constraints.multi_constraint import MultiConstraint
+from .constraints.wildcard_constraint import WilcardConstraint
 from .helpers import normalize_version, _expand_stability
 
 
@@ -103,7 +104,7 @@ class VersionParser:
         # to ensure that unstable instances of the current version are allowed.
         # However, if a stability suffix is added to the constraint,
         # then a >= match on the current version is used instead.
-        m = re.match('(?i)^~{}$'.format(version_regex), constraint)
+        m = re.match('(?i)^~=?{}$'.format(version_regex), constraint)
         if m:
             # Work out which position in the version we are operating at
             if m.group(4):
@@ -176,35 +177,12 @@ class VersionParser:
         # A partial version range is treated as an X-Range,
         # so the special character is in fact optional.
         m = re.match(
-            '^(!=)?v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.[xX*])+$',
+            '^(!=|==)?v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:\.[xX*])+$',
             constraint
         )
         if m:
-            if m.group(4):
-                position = 2
-            elif m.group(3):
-                position = 1
-            else:
-                position = 0
-
-            groups = m.groups()[1:]
-            low_version = self._manipulate_version_string(
-                groups, position
-            )
-            high_version = self._manipulate_version_string(
-                groups, position, 1
-            )
-
-            if m.group(1):
-                if low_version == '0.0.0.0':
-                    return Constraint('>=', high_version),
-
-                return self.parse_constraints(f'<{low_version} || >={high_version}'),
-
-            if low_version == '0.0.0.0':
-                return Constraint('<', high_version),
-
-            return Constraint('>=', low_version), Constraint('<', high_version)
+            # We just leave it as is
+            return WilcardConstraint(constraint),
 
         # Basic Comparators
         m = re.match('^(<>|!=|>=?|<=?|==?)?\s*(.*)', constraint)

poetry/utils/appdirs.py

+"""
+This code was taken from https://github.com/ActiveState/appdirs and modified
+to suit our purposes.
+"""
+import os
+import sys
+
+WINDOWS = (sys.platform.startswith("win") or
+           (sys.platform == 'cli' and os.name == 'nt'))
+
+
+def expanduser(path):
+    """
+    Expand ~ and ~user constructions.
+
+    Includes a workaround for http://bugs.python.org/issue14768
+    """
+    expanded = os.path.expanduser(path)
+    if path.startswith('~/') and expanded.startswith('//'):
+        expanded = expanded[1:]
+    return expanded
+
+
+def user_cache_dir(appname):
+    r"""
+    Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+
+    Typical user cache directories are:
+        macOS:      ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Windows:    C:\Users\<username>\AppData\Local\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go
+    in the `CSIDL_LOCAL_APPDATA` directory. This is identical to the
+    non-roaming app data dir (the default returned by `user_data_dir`). Apps
+    typically put cache data somewhere *under* the given dir here. Some
+    examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    """
+    if WINDOWS:
+        # Get the base path
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+
+        # Add our app name and Cache directory to it
+        path = os.path.join(path, appname, "Cache")
+    elif sys.platform == "darwin":
+        # Get the base path
+        path = expanduser("~/Library/Caches")
+
+        # Add our app name to it
+        path = os.path.join(path, appname)
+    else:
+        # Get the base path
+        path = os.getenv("XDG_CACHE_HOME", expanduser("~/.cache"))
+
+        # Add our app name to it
+        path = os.path.join(path, appname)
+
+    return path
+
+
+def user_data_dir(appname, roaming=False):
+    """
+    Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        macOS:                  ~/Library/Application Support/<AppName>
+        Unix:                   ~/.local/share/<AppName>    # or in
+                                $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\ ...
+                                ...Application Data\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local ...
+                                ...Settings\Application Data\<AppName>
+        Win 7  (not roaming):   C:\\Users\<username>\AppData\Local\<AppName>
+        Win 7  (roaming):       C:\\Users\<username>\AppData\Roaming\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if WINDOWS:
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.join(os.path.normpath(_get_win_folder(const)), appname)
+    elif sys.platform == "darwin":
+        path = os.path.join(
+            expanduser('~/Library/Application Support/'),
+            appname,
+        )
+    else:
+        path = os.path.join(
+            os.getenv('XDG_DATA_HOME', expanduser("~/.local/share")),
+            appname,
+        )
+
+    return path
+
+
+def user_config_dir(appname, roaming=True):
+    """Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "roaming" (boolean, default True) can be set False to not use the
+            Windows roaming appdata directory. That means that for users on a
+            Windows network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        macOS:                  same as user_data_dir
+        Unix:                   ~/.config/<AppName>
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by default "~/.config/<AppName>".
+    """
+    if WINDOWS:
+        path = user_data_dir(appname, roaming=roaming)
+    elif sys.platform == "darwin":
+        path = user_data_dir(appname)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', expanduser("~/.config"))
+        path = os.path.join(path, appname)
+
+    return path
+
+
+# for the discussion regarding site_config_dirs locations
+# see <https://github.com/pypa/pip/issues/1733>
+def site_config_dirs(appname):
+    """Return a list of potential user-shared config dirs for this application.
+
+        "appname" is the name of application.
+
+    Typical user config directories are:
+        macOS:      /Library/Application Support/<AppName>/
+        Unix:       /etc or $XDG_CONFIG_DIRS[i]/<AppName>/ for each value in
+                    $XDG_CONFIG_DIRS
+        Win XP:     C:\Documents and Settings\All Users\Application ...
+                    ...Data\<AppName>\
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory
+                    on Vista.)
+        Win 7:      Hidden, but writeable on Win 7:
+                    C:\ProgramData\<AppName>\
+    """
+    if WINDOWS:
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        pathlist = [os.path.join(path, appname)]
+    elif sys.platform == 'darwin':
+        pathlist = [os.path.join('/Library/Application Support', appname)]
+    else:
+        # try looking in $XDG_CONFIG_DIRS
+        xdg_config_dirs = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+        if xdg_config_dirs:
+            pathlist = [
+                os.path.join(expanduser(x), appname)
+                for x in xdg_config_dirs.split(os.pathsep)
+            ]
+        else:
+            pathlist = []
+
+        # always look in /etc directly as well
+        pathlist.append('/etc')
+
+    return pathlist
+
+
+# -- Windows support functions --
+
+def _get_win_folder_from_registry(csidl_name):
+    """
+    This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    import _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    directory, _type = _winreg.QueryValueEx(key, shell_folder_name)
+    return directory
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+
+if WINDOWS:
+    try:
+        import ctypes
+        _get_win_folder = _get_win_folder_with_ctypes
+    except ImportError:
+        _get_win_folder = _get_win_folder_from_registry
+
+
+def _win_path_to_bytes(path):
+    """Encode Windows paths to bytes. Only used on Python 2.
+
+    Motivation is to be consistent with other operating systems where paths
+    are also returned as bytes. This avoids problems mixing bytes and Unicode
+    elsewhere in the codebase. For more details and discussion see
+    <https://github.com/pypa/pip/issues/3463>.
+
+    If encoding using ASCII and MBCS fails, return the original Unicode path.
+    """
+    for encoding in ('ASCII', 'MBCS'):
+        try:
+            return path.encode(encoding)
+        except (UnicodeEncodeError, LookupError):
+            pass
+    return path

poetry/utils/pip_compat.py

+from pip import __version__
+
+from poetry.version import parse
+
+if parse(__version__) >= parse('9.0.2'):
+    from pip._internal.req import InstallRequirement
+    from pip._internal.utils.appdirs import user_cache_dir, user_config_dir
+else:
+    from pip.req import InstallRequirement
+    from pip.utils.appdirs import user_cache_dir, user_config_dir

poetry/version/helpers.py

@@ -30,7 +30,8 @@ def format_python_constraint(constraint):
         return str(constraint)
 
     for version in PYTHON_VERSION:
-        matches = constraint.matches(parser.parse_constraints(version))
+        version_constraint = parser.parse_constraints(version)
+        matches = constraint.matches(version_constraint)
         if not matches:
             formatted.append('!=' + version)
         else:

poetry/version/markers.py

+import operator
+
+from pyparsing import (
+    ParseException, ParseResults, stringStart, stringEnd,
+)
+
+from pyparsing import ZeroOrMore, Group, Forward, QuotedString
+from pyparsing import Literal as L  # noqa
+
+
+class InvalidMarker(ValueError):
+    """
+    An invalid marker was found, users should refer to PEP 508.
+    """
+
+
+class UndefinedComparison(ValueError):
+    """
+    An invalid operation was attempted on a value that doesn't support it.
+    """
+
+
+class UndefinedEnvironmentName(ValueError):
+    """
+    A name was attempted to be used that does not exist inside of the
+    environment.
+    """
+
+
+class Node(object):
+
+    def __init__(self, value):
+        self.value = value
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return "<{0}({1!r})>".format(self.__class__.__name__, str(self))
+
+    def serialize(self):
+        raise NotImplementedError
+
+
+class Variable(Node):
+
+    def serialize(self):
+        return str(self)
+
+
+class Value(Node):
+
+    def serialize(self):
+        return '"{0}"'.format(self)
+
+
+class Op(Node):
+
+    def serialize(self):
+        return str(self)
+
+
+VARIABLE = (
+    L("implementation_version") |
+    L("platform_python_implementation") |
+    L("implementation_name") |
+    L("python_full_version") |
+    L("platform_release") |
+    L("platform_version") |
+    L("platform_machine") |
+    L("platform_system") |
+    L("python_version") |
+    L("sys_platform") |
+    L("os_name") |
+    L("os.name") |  # PEP-345
+    L("sys.platform") |  # PEP-345
+    L("platform.version") |  # PEP-345
+    L("platform.machine") |  # PEP-345
+    L("platform.python_implementation") |  # PEP-345
+    L("python_implementation") |  # undocumented setuptools legacy
+    L("extra")
+)
+ALIASES = {
+    'os.name': 'os_name',
+    'sys.platform': 'sys_platform',
+    'platform.version': 'platform_version',
+    'platform.machine': 'platform_machine',
+    'platform.python_implementation': 'platform_python_implementation',
+    'python_implementation': 'platform_python_implementation'
+}
+VARIABLE.setParseAction(lambda s, l, t: Variable(ALIASES.get(t[0], t[0])))
+
+VERSION_CMP = (
+    L("===") |
+    L("==") |
+    L(">=") |
+    L("<=") |
+    L("!=") |
+    L("~=") |
+    L(">") |
+    L("<")
+)
+
+MARKER_OP = VERSION_CMP | L("not in") | L("in")
+MARKER_OP.setParseAction(lambda s, l, t: Op(t[0]))
+
+MARKER_VALUE = QuotedString("'") | QuotedString('"')
+MARKER_VALUE.setParseAction(lambda s, l, t: Value(t[0]))
+
+BOOLOP = L("and") | L("or")
+
+MARKER_VAR = VARIABLE | MARKER_VALUE
+
+MARKER_ITEM = Group(MARKER_VAR + MARKER_OP + MARKER_VAR)
+MARKER_ITEM.setParseAction(lambda s, l, t: tuple(t[0]))
+
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+
+MARKER_EXPR = Forward()
+MARKER_ATOM = MARKER_ITEM | Group(LPAREN + MARKER_EXPR + RPAREN)
+MARKER_EXPR << MARKER_ATOM + ZeroOrMore(BOOLOP + MARKER_EXPR)
+
+MARKER = stringStart + MARKER_EXPR + stringEnd
+
+
+def _coerce_parse_result(results):
+    if isinstance(results, ParseResults):
+        return [_coerce_parse_result(i) for i in results]
+    else:
+        return results
+
+
+def _format_marker(marker, first=True):
+    assert isinstance(marker, (list, tuple, str))
+
+    # Sometimes we have a structure like [[...]] which is a single item list
+    # where the single item is itself it's own list. In that case we want skip
+    # the rest of this function so that we don't get extraneous () on the
+    # outside.
+    if (isinstance(marker, list) and len(marker) == 1 and
+            isinstance(marker[0], (list, tuple))):
+        return _format_marker(marker[0])
+
+    if isinstance(marker, list):
+        inner = (_format_marker(m, first=False) for m in marker)
+        if first:
+            return " ".join(inner)
+        else:
+            return "(" + " ".join(inner) + ")"
+    elif isinstance(marker, tuple):
+        return " ".join([m.serialize() for m in marker])
+    else:
+        return marker
+
+
+_operators = {
+    "in": lambda lhs, rhs: lhs in rhs,
+    "not in": lambda lhs, rhs: lhs not in rhs,
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">=": operator.ge,
+    ">": operator.gt,
+}
+
+
+def format_full_version(info):
+    version = '{0.major}.{0.minor}.{0.micro}'.format(info)
+    kind = info.releaselevel
+    if kind != 'final':
+        version += kind[0] + str(info.serial)
+    return version
+
+
+class Marker(object):
+
+    def __init__(self, marker):
+        try:
+            self._markers = _coerce_parse_result(MARKER.parseString(marker))
+        except ParseException as e:
+            err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(
+                marker, marker[e.loc:e.loc + 8])
+            raise InvalidMarker(err_str)
+
+    @property
+    def markers(self):
+        return self._markers
+
+    def __str__(self):
+        return _format_marker(self._markers)
+
+    def __repr__(self):
+        return "<Marker({0!r})>".format(str(self))

poetry/version/requirements.py

+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+from __future__ import absolute_import, division, print_function
+
+import string
+import re
+import urllib.parse as urlparse
+
+from pyparsing import (
+    stringStart, stringEnd, originalTextFor, ParseException
+)
+from pyparsing import ZeroOrMore, Word, Optional, Regex, Combine
+from pyparsing import Literal as L  # noqa
+
+from poetry.semver.version_parser import VersionParser
+
+from .markers import MARKER_EXPR, Marker
+
+
+LEGACY_REGEX = (
+    r"""
+    (?P<operator>(==|!=|<=|>=|<|>))
+    \s*
+    (?P<version>
+        [^,;\s)]* # Since this is a "legacy" specifier, and the version
+                  # string can be just about anything, we match everything
+                  # except for whitespace, a semi-colon for marker support,
+                  # a closing paren since versions can be enclosed in
+                  # them, and a comma since it's a version separator.
+    )
+    """
+)
+
+
+REGEX = (
+    r"""
+            (?P<operator>(~=|==|!=|<=|>=|<|>|===))
+            (?P<version>
+                (?:
+                    # The identity operators allow for an escape hatch that will
+                    # do an exact string match of the version you wish to install.
+                    # This will not be parsed by PEP 440 and we cannot determine
+                    # any semantic meaning from it. This operator is discouraged
+                    # but included entirely as an escape hatch.
+                    (?<====)  # Only match for the identity operator
+                    \s*
+                    [^\s]*    # We just match everything, except for whitespace
+                              # since we are only testing for strict identity.
+                )
+                |
+                (?:
+                    # The (non)equality operators allow for wild card and local
+                    # versions to be specified so we have to define these two
+                    # operators separately to enable that.
+                    (?<===|!=)            # Only match for equals and not equals
+    
+                    \s*
+                    v?
+                    (?:[0-9]+!)?          # epoch
+                    [0-9]+(?:\.[0-9]+)*   # release
+                    (?:                   # pre release
+                        [-_\.]?
+                        (a|b|c|rc|alpha|beta|pre|preview)
+                        [-_\.]?
+                        [0-9]*
+                    )?
+                    (?:                   # post release
+                        (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                    )?
+    
+                    # You cannot use a wild card and a dev or local version
+                    # together so group them with a | and make them optional.
+                    (?:
+                        (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
+                        (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
+                        |
+                        \.\*  # Wild card syntax of .*
+                    )?
+                )
+                |
+                (?:
+                    # The compatible operator requires at least two digits in the
+                    # release segment.
+                    (?<=~=)               # Only match for the compatible operator
+    
+                    \s*
+                    v?
+                    (?:[0-9]+!)?          # epoch
+                    [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
+                    (?:                   # pre release
+                        [-_\.]?
+                        (a|b|c|rc|alpha|beta|pre|preview)
+                        [-_\.]?
+                        [0-9]*
+                    )?
+                    (?:                                   # post release
+                        (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                    )?
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+                )
+                |
+                (?:
+                    # All other operators only allow a sub set of what the
+                    # (non)equality operators do. Specifically they do not allow
+                    # local versions to be specified nor do they allow the prefix
+                    # matching wild cards.
+                    (?<!==|!=|~=)         # We have special cases for these
+                                          # operators so we want to make sure they
+                                          # don't match here.
+    
+                    \s*
+                    v?
+                    (?:[0-9]+!)?          # epoch
+                    [0-9]+(?:\.[0-9]+)*   # release
+                    (?:                   # pre release
+                        [-_\.]?
+                        (a|b|c|rc|alpha|beta|pre|preview)
+                        [-_\.]?
+                        [0-9]*
+                    )?
+                    (?:                                   # post release
+                        (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
+                    )?
+                    (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
+                )
+            )
+"""
+)
+
+
+class InvalidRequirement(ValueError):
+    """
+    An invalid requirement was found, users should refer to PEP 508.
+    """
+
+
+ALPHANUM = Word(string.ascii_letters + string.digits)
+
+LBRACKET = L("[").suppress()
+RBRACKET = L("]").suppress()
+LPAREN = L("(").suppress()
+RPAREN = L(")").suppress()
+COMMA = L(",").suppress()
+SEMICOLON = L(";").suppress()
+AT = L("@").suppress()
+
+PUNCTUATION = Word("-_.")
+IDENTIFIER_END = ALPHANUM | (ZeroOrMore(PUNCTUATION) + ALPHANUM)
+IDENTIFIER = Combine(ALPHANUM + ZeroOrMore(IDENTIFIER_END))
+
+NAME = IDENTIFIER("name")
+EXTRA = IDENTIFIER
+
+URI = Regex(r'[^ ]+')("url")
+URL = (AT + URI)
+
+EXTRAS_LIST = EXTRA + ZeroOrMore(COMMA + EXTRA)
+EXTRAS = (LBRACKET + Optional(EXTRAS_LIST) + RBRACKET)("extras")
+
+VERSION_PEP440 = Regex(REGEX, re.VERBOSE | re.IGNORECASE)
+VERSION_LEGACY = Regex(LEGACY_REGEX, re.VERBOSE | re.IGNORECASE)
+
+VERSION_ONE = VERSION_PEP440 ^ VERSION_LEGACY
+VERSION_MANY = Combine(VERSION_ONE + ZeroOrMore(COMMA + VERSION_ONE),
+                       joinString=",", adjacent=False)("_raw_spec")
+_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))
+_VERSION_SPEC.setParseAction(lambda s, l, t: t._raw_spec or '')
+
+VERSION_SPEC = originalTextFor(_VERSION_SPEC)("specifier")
+VERSION_SPEC.setParseAction(lambda s, l, t: t[1])
+
+MARKER_EXPR = originalTextFor(MARKER_EXPR())("marker")
+MARKER_EXPR.setParseAction(
+    lambda s, l, t: Marker(s[t._original_start:t._original_end])
+)
+MARKER_SEPERATOR = SEMICOLON
+MARKER = MARKER_SEPERATOR + MARKER_EXPR
+
+VERSION_AND_MARKER = VERSION_SPEC + Optional(MARKER)
+URL_AND_MARKER = URL + Optional(MARKER)
+
+NAMED_REQUIREMENT = \
+    NAME + Optional(EXTRAS) + (URL_AND_MARKER | VERSION_AND_MARKER)
+
+REQUIREMENT = stringStart + NAMED_REQUIREMENT + stringEnd
+
+
+class Requirement(object):
+    """Parse a requirement.
+
+    Parse a given requirement string into its parts, such as name, specifier,
+    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
+    string.
+    """
+
+    def __init__(self, requirement_string):
+        try:
+            req = REQUIREMENT.parseString(requirement_string)
+        except ParseException as e:
+            raise InvalidRequirement(
+                "Invalid requirement, parse error at \"{0!r}\"".format(
+                    requirement_string[e.loc:e.loc + 8]))
+
+        self.name = req.name
+        if req.url:
+            parsed_url = urlparse.urlparse(req.url)
+            if not (parsed_url.scheme and parsed_url.netloc) or (
+                    not parsed_url.scheme and not parsed_url.netloc):
+                raise InvalidRequirement("Invalid URL given")
+            self.url = req.url
+        else:
+            self.url = None
+
+        self.extras = set(req.extras.asList() if req.extras else [])
+        constraint = req.specifier
+        if not constraint:
+            constraint = '*'
+
+        self.constraint = VersionParser().parse_constraints(constraint)
+        self.pretty_constraint = constraint
+
+        self.marker = req.marker if req.marker else None
+
+    def __str__(self):
+        parts = [self.name]
+
+        if self.extras:
+            parts.append("[{0}]".format(",".join(sorted(self.extras))))
+
+        if self.pretty_constraint:
+            parts.append(self.pretty_constraint)
+
+        if self.url:
+            parts.append("@ {0}".format(self.url))
+
+        if self.marker:
+            parts.append("; {0}".format(self.marker))
+
+        return "".join(parts)
+
+    def __repr__(self):
+        return "<Requirement({0!r})>".format(str(self))

pyproject.toml

@@ -26,6 +26,7 @@ pip-tools = "^1.11"
 requests-toolbelt = "^0.8.0"
 jsonschema = "^2.6"
 pyrsistent = "^0.14.2"
+pyparsing = "^2.2"
 
 [tool.poetry.dev-dependencies]
 pytest = "~3.4"

tests/packages/test_main.py

+from poetry.packages import dependency_from_pep_508
+
+
+def test_dependency_from_pep_508():
+    name = 'requests'
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == name
+    assert str(dep.constraint) == '*'
+
+
+def test_dependency_from_pep_508_with_version():
+    name = 'requests==2.18.0'
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == 'requests'
+    assert str(dep.constraint) == '== 2.18.0.0'
+
+
+def test_dependency_from_pep_508_with_parens():
+    name = 'requests (==2.18.0)'
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == 'requests'
+    assert str(dep.constraint) == '== 2.18.0.0'
+
+
+def test_dependency_from_pep_508_with_constraint():
+    name = 'requests>=2.12.0,!=2.17.*,<3.0'
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == 'requests'
+    assert str(dep.constraint) == '>= 2.12.0.0, != 2.17.*, < 3.0.0.0'
+
+
+def test_dependency_from_pep_508_with_extras():
+    name = 'requests==2.18.0; extra == "foo" or extra == "bar"'
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == 'requests'
+    assert str(dep.constraint) == '== 2.18.0.0'
+    assert dep.extras == ['foo', 'bar']
+
+
+def test_dependency_from_pep_508_with_python_version():
+    name = (
+        'requests (==2.18.0); '
+        'python_version == "2.7" or python_version == "2.6"'
+    )
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == 'requests'
+    assert str(dep.constraint) == '== 2.18.0.0'
+    assert dep.extras == []
+    assert dep.python_versions == '~2.7 || ~2.6'
+
+
+def test_dependency_from_pep_508_with_platform():
+    name = (
+        'requests (==2.18.0); '
+        'sys_platform == "win32" or sys_platform == "darwin"'
+    )
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == 'requests'
+    assert str(dep.constraint) == '== 2.18.0.0'
+    assert dep.extras == []
+    assert dep.python_versions == '*'
+    assert dep.platform == 'win32 || darwin'
+
+
+def test_dependency_from_pep_508_complex():
+    name = (
+        'requests (==2.18.0); '
+        'python_version >= "2.7" and python_version != "3.2" '
+        'and (sys_platform == "win32" or sys_platform == "darwin") '
+        'and extra == "foo"'
+    )
+    dep = dependency_from_pep_508(name)
+
+    assert dep.name == 'requests'
+    assert str(dep.constraint) == '== 2.18.0.0'
+    assert dep.extras == ['foo']
+    assert dep.python_versions == '>=2.7 !=3.2.*'
+    assert dep.platform == 'win32 || darwin'

tests/repositories/test_pypi_repository.py

@@ -38,5 +38,5 @@ def test_package():
 
     win_inet = package.extras['socks'][0]
     assert win_inet.name == 'win-inet-pton'
-    assert win_inet.python_versions == '==2.7 || ==2.6'
+    assert win_inet.python_versions == '~2.7 || ~2.6'
     assert win_inet.platform == 'win32'

tests/semver/test_version_parser.py

@@ -57,7 +57,8 @@ def test_parse_constraints_wildcard(parser, input, min, max):
     else:
         expected = max
 
-    assert str(parser.parse_constraints(input)) == str(expected)
+    constraint = parser.parse_constraints(input)
+    assert str(constraint.constraint) == str(expected)
 
 
 @pytest.mark.parametrize(
@@ -76,7 +77,8 @@ def test_parse_constraints_negative_wildcard(parser, input, min, max):
     else:
         expected = max
 
-    assert str(parser.parse_constraints(input)) == str(expected)
+    constraint = parser.parse_constraints(input)
+    assert str(constraint.constraint) == str(expected)
 
 
 @pytest.mark.parametrize(