def test_comparison():
versions = [
"1.0.0-alpha",
"1.0.0-alpha.1",
"1.0.0-beta.2",
"1.0.0-beta.11",
"1.0.0-rc.1",
"1.0.0-rc.1+build.1",
"1.0.0",
"1.0.0+0.3.7",
"1.3.7+build",
"1.3.7+build.2.b8f12d7",
"1.3.7+build.11.e0f985a",
"2.0.0",
"2.1.0",
"2.2.0",
"2.11.0",
"2.11.1",
]
for i in range(len(versions)):
for j in range(len(versions)):
a = Version.parse(versions[i])
b = Version.parse(versions[j])
assert (a < b) == (i < j)
assert (a > b) == (i > j)
assert (a <= b) == (i <= j)
assert (a >= b) == (i >= j)
assert (a == b) == (i == j)
assert (a != b) == (i != j)
def test_allows_any():
v = Version.parse("1.2.3")
assert v.allows_any(v)
assert not v.allows_any(Version.parse("0.0.3"))
assert v.allows_any(VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4")))
assert v.allows_any(VersionRange())
assert not v.allows_any(EmptyConstraint())
def all_classifiers(self):
classifiers = copy.copy(self.classifiers)
# Automatically set python classifiers
if self.python_versions == "*":
python_constraint = parse_constraint("~2.7 || ^3.4")
else:
python_constraint = self.python_constraint
for version in sorted(self.AVAILABLE_PYTHONS):
if len(version) == 1:
constraint = parse_constraint(version + ".*")
else:
constraint = Version.parse(version)
if python_constraint.allows_any(constraint):
classifiers.append(
"Programming Language :: Python :: {}".format(version)
)
# Automatically set license classifiers
if self.license:
classifiers.append(self.license.classifier)
classifiers = set(classifiers)
return sorted(classifiers)
def _get_release_info(self, name, version): # type: (str, str) -> dict
page = self._get("/{}/".format(canonicalize_name(name).replace(".", "-")))
if page is None:
raise ValueError('No package named "{}"'.format(name))
data = {
"name": name,
"version": version,
"summary": "",
"requires_dist": [],
"requires_python": [],
"digests": [],
}
links = list(page.links_for_version(Version.parse(version)))
urls = {}
hashes = []
default_link = links[0]
for link in links:
if link.is_wheel:
urls["bdist_wheel"] = link.url
elif link.filename.endswith(".tar.gz"):
urls["sdist"] = link.url
elif link.filename.endswith((".zip", ".bz2")) and "sdist" not in urls:
urls["sdist"] = link.url
hash = link.hash
if link.hash_name == "sha256":
hashes.append(hash)
data["digests"] = hashes
if not urls:
if default_link.is_wheel:
m = wheel_file_re.match(default_link.filename)
python = m.group("pyver")
platform = m.group("plat")
if python == "py2.py3" and platform == "any":
urls["bdist_wheel"] = default_link.url
elif default_link.filename.endswith(".tar.gz"):
urls["sdist"] = default_link.url
elif (
default_link.filename.endswith((".zip", ".bz2")) and "sdist" not in urls
):
urls["sdist"] = default_link.url
else:
return data
info = self._get_info_from_urls(urls)
data["summary"] = info["summary"]
data["requires_dist"] = info["requires_dist"]
data["requires_python"] = info["requires_python"]
return data
def test_allows():
v = Version.parse("1.2.3")
assert v.allows(v)
assert not v.allows(Version.parse("2.2.3"))
assert not v.allows(Version.parse("1.3.3"))
assert not v.allows(Version.parse("1.2.4"))
assert not v.allows(Version.parse("1.2.3-dev"))
assert not v.allows(Version.parse("1.2.3+build"))
def increment_version(self, version, rule):
from poetry.semver import Version
try:
version = Version.parse(version)
except ValueError:
raise ValueError("The project's version doesn't seem to follow semver")
if rule in {"major", "premajor"}:
new = version.next_major
if rule == "premajor":
new = new.first_prerelease
elif rule in {"minor", "preminor"}:
new = version.next_minor
if rule == "preminor":
new = new.first_prerelease
elif rule in {"patch", "prepatch"}:
new = version.next_patch
if rule == "prepatch":
new = new.first_prerelease
elif rule == "prerelease":
if version.is_prerelease():
pre = version.prerelease
new_prerelease = int(pre[1]) + 1
new = Version.parse(
"{}.{}.{}-{}".format(
version.major,
version.minor,
version.patch,
".".join([pre[0], str(new_prerelease)]),
)
)
else:
new = version.next_patch.first_prerelease
else:
new = Version.parse(rule)
return new
def __init__(self, name, version, pretty_version=None):
"""
Creates a new in memory package.
"""
self._pretty_name = name
self._name = canonicalize_name(name)
if not isinstance(version, Version):
self._version = Version.parse(version)
self._pretty_version = pretty_version or version
else:
self._version = version
self._pretty_version = pretty_version or self._version.text
self.description = ""
self._authors = []
self.homepage = None
self.repository_url = None
self.keywords = []
self._license = None
self.readme = None
self.source_type = ""
self.source_reference = ""
self.source_url = ""
self.requires = []
self.dev_requires = []
self.extras = {}
self.requires_extras = []
self.category = "main"
self.hashes = []
self.optional = False
# Requirements for making it mandatory
self.requirements = {}
self.classifiers = []
self._python_versions = "*"
self._python_constraint = parse_constraint("*")
self._platform = "*"
self._platform_constraint = EmptyConstraint()
self.root_dir = None
self.develop = False
def test_difference():
v = Version.parse("1.2.3")
assert v.difference(v).is_empty()
assert v.difference(Version.parse("0.8.0")) == v
assert v.difference(
VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4"))
).is_empty()
assert (
v.difference(VersionRange(Version.parse("1.4.0"), Version.parse("3.0.0"))) == v
)
def link_version(self, link): # type: (Link) -> Union[Version, None]
m = wheel_file_re.match(link.filename)
if m:
version = m.group("ver")
else:
info, ext = link.splitext()
match = self.VERSION_REGEX.match(info)
if not match:
return
version = match.group(2)
try:
version = Version.parse(version)
except ValueError:
return
return version
def test_intersect():
v = Version.parse("1.2.3")
assert v.intersect(v) == v
assert v.intersect(Version.parse("1.1.4")).is_empty()
assert (
v.intersect(VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4"))) == v
)
assert (
Version.parse("1.1.4")
.intersect(VersionRange(v, Version.parse("1.2.4")))
.is_empty()
)
def _transform_version(self, version, pretty_version):
# attempt to transform 2.1.1 to 2.1
# this allows you to upgrade through minor versions
try:
parsed = Version.parse(version)
parts = [parsed.major, parsed.minor, parsed.patch]
except ValueError:
return pretty_version
# check to see if we have a semver-looking version
if len(parts) == 3:
# remove the last parts (the patch version number and any extra)
if parts[0] != 0:
del parts[2]
version = ".".join(str(p) for p in parts)
if parsed.is_prerelease():
version += "-{}".format(".".join(str(p) for p in parsed.prerelease))
else:
return pretty_version
return "^{}".format(version)
def _transform_version(self, version, pretty_version):
# attempt to transform 2.1.1 to 2.1
# this allows you to upgrade through minor versions
try:
parsed = Version.parse(version)
parts = [parsed.major, parsed.minor, parsed.patch]
except ValueError:
return pretty_version
# check to see if we have a semver-looking version
if len(parts) == 3:
# remove the last parts (the patch version number and any extra)
if parts[0] != 0:
del parts[2]
version = ".".join(str(p) for p in parts)
if parsed.is_prerelease():
version += "-{}".format(".".join(str(p) for p in parsed.prerelease))
else:
return pretty_version
return "^{}".format(version)
def test_create_venv_tries_to_find_a_compatible_python_executable_using_generic_ones_first(
manager, poetry, config, mocker):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
poetry.package.python_versions = "^3.6"
venv_name = manager.generate_env_name("simple-project",
str(poetry.file.parent))
mocker.patch("sys.version_info", (2, 7, 16))
mocker.patch(
"poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(Version.parse("3.7.5")),
)
m = mocker.patch("poetry.utils.env.EnvManager.build_venv",
side_effect=lambda *args, **kwargs: "")
manager.create_venv(NullIO())
m.assert_called_with(str(
Path("/foo/virtualenvs/{}-py3.7".format(venv_name))),
executable="python3")
def test_activate_activates_different_virtualenv_with_envs_file(
tmp_dir, manager, poetry, config, mocker):
if "VIRTUAL_ENV" in os.environ:
del os.environ["VIRTUAL_ENV"]
venv_name = manager.generate_env_name("simple-project",
str(poetry.file.parent))
envs_file = TomlFile(Path(tmp_dir) / "envs.toml")
doc = tomlkit.document()
doc[venv_name] = {"minor": "3.7", "patch": "3.7.1"}
envs_file.write(doc)
os.mkdir(os.path.join(tmp_dir, "{}-py3.7".format(venv_name)))
config.merge({"virtualenvs": {"path": str(tmp_dir)}})
mocker.patch(
"poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(Version.parse("3.6.6")),
)
mocker.patch(
"poetry.utils._compat.subprocess.Popen.communicate",
side_effect=[("/prefix", None), ("/prefix", None), ("/prefix", None)],
)
m = mocker.patch("poetry.utils.env.EnvManager.build_venv",
side_effect=build_venv)
env = manager.activate("python3.6", NullIO())
m.assert_called_with(os.path.join(tmp_dir, "{}-py3.6".format(venv_name)),
executable="python3.6")
assert envs_file.exists()
envs = envs_file.read()
assert envs[venv_name]["minor"] == "3.6"
assert envs[venv_name]["patch"] == "3.6.6"
assert env.path == Path(tmp_dir) / "{}-py3.6".format(venv_name)
assert env.base == Path("/prefix")
def test_get_prefers_explicitly_activated_virtualenvs_over_env_var(
app, tmp_dir, config, mocker):
app.poetry._config = config
os.environ["VIRTUAL_ENV"] = "/environment/prefix"
venv_name = EnvManager.generate_env_name("simple_project",
str(app.poetry.file.parent))
current_python = sys.version_info[:3]
python_minor = ".".join(str(v) for v in current_python[:2])
python_patch = ".".join(str(v) for v in current_python)
config.add_property("settings.virtualenvs.path", str(tmp_dir))
(Path(tmp_dir) / "{}-py{}".format(venv_name, python_minor)).mkdir()
envs_file = TomlFile(Path(tmp_dir) / "envs.toml")
doc = tomlkit.document()
doc[venv_name] = {"minor": python_minor, "patch": python_patch}
envs_file.write(doc)
mocker.patch(
"poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(Version(*current_python)),
)
mocker.patch(
"poetry.utils._compat.subprocess.Popen.communicate",
side_effect=[("/prefix", None), ("/prefix", None), ("/prefix", None)],
)
command = app.find("env use")
tester = CommandTester(command)
tester.execute(python_minor)
expected = """\
Using virtualenv: {}
""".format(os.path.join(tmp_dir, "{}-py{}".format(venv_name, python_minor)))
assert expected == tester.io.fetch_output()
def test_remove_also_deactivates(tmp_dir, manager, poetry, config, mocker):
config.merge({"virtualenvs": {"path": str(tmp_dir)}})
venv_name = manager.generate_env_name("simple-project", str(poetry.file.parent))
(Path(tmp_dir) / "{}-py3.7".format(venv_name)).mkdir()
(Path(tmp_dir) / "{}-py3.6".format(venv_name)).mkdir()
mocker.patch(
"poetry.utils._compat.subprocess.check_output",
side_effect=check_output_wrapper(Version.parse("3.6.6")),
)
envs_file = TomlFile(Path(tmp_dir) / "envs.toml")
doc = tomlkit.document()
doc[venv_name] = {"minor": "3.6", "patch": "3.6.6"}
envs_file.write(doc)
venv = manager.remove("python3.6")
assert (Path(tmp_dir) / "{}-py3.6".format(venv_name)) == venv.path
assert not (Path(tmp_dir) / "{}-py3.6".format(venv_name)).exists()
envs = envs_file.read()
assert venv_name not in envs
def v140():
return Version.parse("1.4.0")
def v114():
return Version.parse("1.1.4")
def v124():
return Version.parse("1.2.4")
def test_allows_any(v003, v010, v072, v080, v114, v123, v124, v140, v200, v234,
v250, v300):
# disallows an empty constraint
assert not VersionRange(v123, v250).allows_any(EmptyConstraint())
# allows allowed versions
range = VersionRange(v123, v250, include_max=True)
assert not range.allows_any(v123)
assert range.allows_any(v124)
assert range.allows_any(v250)
assert not range.allows_any(v300)
# with no min
range = VersionRange(max=v200)
assert range.allows_any(VersionRange(v140, v300))
assert not range.allows_any(VersionRange(v234, v300))
assert range.allows_any(VersionRange(v140))
assert not range.allows_any(VersionRange(v234))
assert range.allows_any(range)
# with no max
range = VersionRange(min=v072)
assert range.allows_any(VersionRange(v003, v140))
assert not range.allows_any(VersionRange(v003, v010))
assert range.allows_any(VersionRange(max=v080))
assert not range.allows_any(VersionRange(max=v003))
assert range.allows_any(range)
# with min and max
range = VersionRange(v072, v200)
assert range.allows_any(VersionRange(v003, v140))
assert range.allows_any(VersionRange(v140, v300))
assert not range.allows_any(VersionRange(v003, v010))
assert not range.allows_any(VersionRange(v234, v300))
assert not range.allows_any(VersionRange(max=v010))
assert not range.allows_any(VersionRange(v234))
assert range.allows_any(range)
# allows a bordering range when both are inclusive
assert not VersionRange(max=v250).allows_any(VersionRange(min=v250))
assert not VersionRange(max=v250, include_max=True).allows_any(
VersionRange(min=v250))
assert not VersionRange(max=v250).allows_any(
VersionRange(min=v250, include_min=True))
assert not VersionRange(min=v250).allows_any(VersionRange(max=v250))
assert VersionRange(max=v250, include_max=True).allows_any(
VersionRange(min=v250, include_min=True))
# allows unions that are partially contained'
range = VersionRange(v114, v200)
assert range.allows_any(VersionRange(v010, v080).union(v140))
assert range.allows_any(VersionRange(v123, v234).union(v300))
assert not range.allows_any(VersionRange(v234, v300).union(v010))
# pre-release min does not allow lesser than itself
range = VersionRange(Version.parse("1.9b1"), include_min=True)
assert not range.allows_any(
VersionRange(
Version.parse("1.8.0"),
Version.parse("1.9.0"),
include_min=True,
always_include_max_prerelease=True,
))
def v080():
return Version.parse("0.8.0")
def handle(self):
from poetry.packages.constraints import (
parse_constraint as parse_generic_constraint, )
from poetry.repositories.installed_repository import InstalledRepository
from poetry.semver import Version
from poetry.semver import parse_constraint
package = self.argument("package")
if self.option("tree"):
self.init_styles()
if self.option("outdated"):
self.input.set_option("latest", True)
locked_repo = self.poetry.locker.locked_repository(
not self.option("no-dev"))
# Show tree view if requested
if self.option("tree") and not package:
requires = self.poetry.package.requires + self.poetry.package.dev_requires
packages = locked_repo.packages
for package in packages:
for require in requires:
if package.name == require.name:
self.display_package_tree(package, locked_repo)
break
return 0
table = self.table(style="compact")
table.get_style().set_vertical_border_char("")
locked_packages = locked_repo.packages
if package:
pkg = None
for locked in locked_packages:
if package.lower() == locked.name:
pkg = locked
break
if not pkg:
raise ValueError("Package {} not found".format(package))
if self.option("tree"):
self.display_package_tree(pkg, locked_repo)
return 0
rows = [
["<info>name</>", " : <fg=cyan>{}</>".format(pkg.pretty_name)],
[
"<info>version</>",
" : <comment>{}</>".format(pkg.pretty_version)
],
["<info>description</>", " : {}".format(pkg.description)],
]
table.add_rows(rows)
table.render()
if pkg.requires:
self.line("")
self.line("<info>dependencies</info>")
for dependency in pkg.requires:
self.line(" - {} <comment>{}</>".format(
dependency.pretty_name, dependency.pretty_constraint))
return 0
show_latest = self.option("latest")
show_all = self.option("all")
terminal = self.get_application().terminal
width = terminal.width
name_length = version_length = latest_length = 0
latest_packages = {}
installed_repo = InstalledRepository.load(self.env)
skipped = []
python = Version.parse(".".join(
[str(i) for i in self.env.version_info[:3]]))
# Computing widths
for locked in locked_packages:
python_constraint = locked.python_constraint
if not python_constraint.allows(
python) or not self.env.is_valid_for_marker(locked.marker):
skipped.append(locked)
if not show_all:
continue
current_length = len(locked.pretty_name)
if not self.output.is_decorated():
installed_status = self.get_installed_status(
locked, installed_repo)
if installed_status == "not-installed":
current_length += 4
name_length = max(name_length, current_length)
version_length = max(version_length,
len(locked.full_pretty_version))
if show_latest:
latest = self.find_latest_package(locked)
if not latest:
latest = locked
latest_packages[locked.pretty_name] = latest
latest_length = max(latest_length,
len(latest.full_pretty_version))
write_version = name_length + version_length + 3 <= width
write_latest = name_length + version_length + latest_length + 3 <= width
write_description = name_length + version_length + latest_length + 24 <= width
for locked in locked_packages:
color = "green"
name = locked.pretty_name
install_marker = ""
if locked in skipped:
if not show_all:
continue
color = "black;options=bold"
else:
installed_status = self.get_installed_status(
locked, installed_repo)
if installed_status == "not-installed":
color = "red"
if not self.output.is_decorated():
# Non installed in non decorated mode
install_marker = " (!)"
line = "<fg={}>{:{}}{}</>".format(
color, name, name_length - len(install_marker), install_marker)
if write_version:
line += " <comment>{:{}}</comment>".format(
locked.full_pretty_version, version_length)
if show_latest and write_latest:
latest = latest_packages[locked.pretty_name]
update_status = self.get_update_status(latest, locked)
color = "green"
if update_status == "semver-safe-update":
color = "red"
elif update_status == "update-possible":
color = "yellow"
line += " <fg={}>{:{}}</>".format(color, latest.pretty_version,
latest_length)
if self.option("outdated") and update_status == "up-to-date":
continue
if write_description:
description = locked.description
remaining = width - name_length - version_length - 4
if show_latest:
remaining -= latest_length
if len(locked.description) > remaining:
description = description[:remaining - 3] + "..."
line += " " + description
self.line(line)
def _get_release_info(self, name, version): # type: (str, str) -> dict
page = self._get("/{}/".format(canonicalize_name(name).replace(".", "-")))
if page is None:
raise PackageNotFound('No package named "{}"'.format(name))
data = {
"name": name,
"version": version,
"summary": "",
"requires_dist": [],
"requires_python": None,
"digests": [],
}
links = list(page.links_for_version(Version.parse(version)))
if not links:
raise PackageNotFound(
'No valid distribution links found for package: "{}" version: "{}"'.format(
name, version
)
)
urls = {}
hashes = []
default_link = links[0]
for link in links:
if link.is_wheel:
m = wheel_file_re.match(default_link.filename)
python = m.group("pyver")
platform = m.group("plat")
if python == "py2.py3" and platform == "any":
urls["bdist_wheel"] = default_link.url
elif link.filename.endswith(".tar.gz"):
urls["sdist"] = link.url
elif (
link.filename.endswith((".zip", ".bz2", ".xz", ".Z", ".tar"))
and "sdist" not in urls
):
urls["sdist"] = link.url
hash = link.hash
if link.hash_name == "sha256":
hashes.append(hash)
data["digests"] = hashes
if not urls:
if default_link.is_wheel:
urls["bdist_wheel"] = default_link.url
elif default_link.filename.endswith(".tar.gz"):
urls["sdist"] = default_link.url
elif (
default_link.filename.endswith((".zip", ".bz2")) and "sdist" not in urls
):
urls["sdist"] = default_link.url
else:
return data
info = self._get_info_from_urls(urls)
data["summary"] = info["summary"]
data["requires_dist"] = info["requires_dist"]
data["requires_python"] = info["requires_python"]
return data
def v234():
return Version.parse("2.3.4")
def v200():
return Version.parse("2.0.0")
def v300():
return Version.parse("3.0.0")
def v250():
return Version.parse("2.5.0")
def test_equality():
assert Version.parse("1.2.3") == Version.parse("01.2.3")
assert Version.parse("1.2.3") == Version.parse("1.02.3")
assert Version.parse("1.2.3") == Version.parse("1.2.03")
assert Version.parse("1.2.3-1") == Version.parse("1.2.3-01")
assert Version.parse("1.2.3+1") == Version.parse("1.2.3+01")
def v003():
return Version.parse("0.0.3")
def test_parse_valid(input, version):
parsed = Version.parse(input)
assert parsed == version
assert parsed.text == input
def v234():
return Version.parse("2.3.4")
def v140():
return Version.parse("1.4.0")
def v300():
return Version.parse("3.0.0")
def handle(self):
from poetry.packages.constraints.generic_constraint import GenericConstraint
from poetry.repositories.installed_repository import InstalledRepository
from poetry.semver import Version
from poetry.semver import parse_constraint
package = self.argument("package")
if self.option("tree"):
self.init_styles()
if self.option("outdated"):
self.input.set_option("latest", True)
locked_repo = self.poetry.locker.locked_repository(True)
# Show tree view if requested
if self.option("tree") and not package:
requires = self.poetry.package.requires + self.poetry.package.dev_requires
packages = locked_repo.packages
for package in packages:
for require in requires:
if package.name == require.name:
self.display_package_tree(package, locked_repo)
break
return 0
table = self.table(style="compact")
table.get_style().set_vertical_border_char("")
locked_packages = locked_repo.packages
if package:
pkg = None
for locked in locked_packages:
if package.lower() == locked.name:
pkg = locked
break
if not pkg:
raise ValueError("Package {} not found".format(package))
if self.option("tree"):
self.display_package_tree(pkg, locked_repo)
return 0
rows = [
["<info>name</>", " : <fg=cyan>{}</>".format(pkg.pretty_name)],
["<info>version</>", " : <comment>{}</>".format(pkg.pretty_version)],
["<info>description</>", " : {}".format(pkg.description)],
]
table.add_rows(rows)
table.render()
if pkg.requires:
self.line("")
self.line("<info>dependencies</info>")
for dependency in pkg.requires:
self.line(
" - {} <comment>{}</>".format(
dependency.pretty_name, dependency.pretty_constraint
)
)
return 0
show_latest = self.option("latest")
show_all = self.option("all")
terminal = self.get_application().terminal
width = terminal.width
name_length = version_length = latest_length = 0
latest_packages = {}
installed_repo = InstalledRepository.load(self.venv)
skipped = []
platform = sys.platform
python = Version.parse(".".join([str(i) for i in self._venv.version_info[:3]]))
# Computing widths
for locked in locked_packages:
python_constraint = parse_constraint(locked.requirements.get("python", "*"))
platform_constraint = GenericConstraint.parse(
locked.requirements.get("platform", "*")
)
if not python_constraint.allows(python) or not platform_constraint.matches(
GenericConstraint("=", platform)
):
skipped.append(locked)
if not show_all:
continue
current_length = len(locked.pretty_name)
if not self.output.is_decorated():
installed_status = self.get_installed_status(locked, installed_repo)
if installed_status == "not-installed":
current_length += 4
name_length = max(name_length, current_length)
version_length = max(version_length, len(locked.full_pretty_version))
if show_latest:
latest = self.find_latest_package(locked)
if not latest:
latest = locked
latest_packages[locked.pretty_name] = latest
latest_length = max(latest_length, len(latest.full_pretty_version))
write_version = name_length + version_length + 3 <= width
write_latest = name_length + version_length + latest_length + 3 <= width
write_description = name_length + version_length + latest_length + 24 <= width
for locked in locked_packages:
color = "green"
name = locked.pretty_name
install_marker = ""
if locked in skipped:
if not show_all:
continue
color = "black;options=bold"
else:
installed_status = self.get_installed_status(locked, installed_repo)
if installed_status == "not-installed":
color = "red"
if not self.output.is_decorated():
# Non installed in non decorated mode
install_marker = " (!)"
line = "<fg={}>{:{}}{}</>".format(
color, name, name_length - len(install_marker), install_marker
)
if write_version:
line += " <comment>{:{}}</comment>".format(
locked.full_pretty_version, version_length
)
if show_latest and write_latest:
latest = latest_packages[locked.pretty_name]
update_status = self.get_update_status(latest, locked)
color = "green"
if update_status == "semver-safe-update":
color = "red"
elif update_status == "update-possible":
color = "yellow"
line += " <fg={}>{:{}}</>".format(
color, latest.pretty_version, latest_length
)
if self.option("outdated") and update_status == "up-to-date":
continue
if write_description:
description = locked.description
remaining = width - name_length - version_length - 4
if show_latest:
remaining -= latest_length
if len(locked.description) > remaining:
description = description[: remaining - 3] + "..."
line += " " + description
self.line(line)
"input",
[">=2.7,!=3.0.*,!=3.1.*", ">=2.7, !=3.0.*, !=3.1.*", ">= 2.7, != 3.0.*, != 3.1.*"],
)
def test_parse_constraint_multi_wilcard(input):
assert parse_constraint(input) == VersionUnion(
VersionRange(Version(2, 7, 0), Version(3, 0, 0), True, False),
VersionRange(Version(3, 2, 0), None, True, False),
)
@pytest.mark.parametrize(
"input,constraint",
[
(
"!=v2.*",
VersionRange(max=Version.parse("2.0")).union(
VersionRange(Version.parse("3.0"), include_min=True)
),
),
(
"!=2.*.*",
VersionRange(max=Version.parse("2.0")).union(
VersionRange(Version.parse("3.0"), include_min=True)
),
),
(
"!=2.0.*",
VersionRange(max=Version.parse("2.0")).union(
VersionRange(Version.parse("2.1"), include_min=True)
),
),
def v130():
return Version.parse("1.3.0")
def _filter_operations(
self, ops, repo
): # type: (List[Operation], Repository) -> None
extra_packages = [p.name for p in self._get_extra_packages(repo)]
for op in ops:
if isinstance(op, Update):
package = op.target_package
else:
package = op.package
if op.job_type == "uninstall":
continue
if package.name in self._develop and package.source_type == "directory":
package.develop = True
if op.skipped:
op.unskip()
python = Version.parse(
".".join([str(i) for i in self._venv.version_info[:3]])
)
if "python" in package.requirements:
python_constraint = parse_constraint(package.requirements["python"])
if not python_constraint.allows(python):
# Incompatible python versions
op.skip("Not needed for the current python version")
continue
if not package.python_constraint.allows(python):
op.skip("Not needed for the current python version")
continue
if "platform" in package.requirements:
platform_constraint = GenericConstraint.parse(
package.requirements["platform"]
)
if not platform_constraint.matches(
GenericConstraint("=", sys.platform)
):
# Incompatible systems
op.skip("Not needed for the current platform")
continue
if self._update:
extras = {}
for extra, deps in self._package.extras.items():
extras[extra] = [dep.name for dep in deps]
else:
extras = {}
for extra, deps in self._locker.lock_data.get("extras", {}).items():
extras[extra] = [dep.lower() for dep in deps]
# If a package is optional and not requested
# in any extra we skip it
if package.optional:
if package.name not in extra_packages:
op.skip("Not required")
# If the package is a dev package and dev packages
# are not requests, we skip it
if package.category == "dev" and not self.is_dev_mode():
op.skip("Dev dependencies not requested")
def v124():
return Version.parse("1.2.4")
def v010():
return Version.parse("0.1.0")
def test_parse_constraint_multi(input):
assert parse_constraint(input) == VersionRange(
Version(2, 0, 0), Version(3, 0, 0), include_min=False, include_max=True
)
def v072():
return Version.parse("0.7.2")
def v080():
return Version.parse("0.8.0")
def v123():
return Version.parse("1.2.3")
def v200():
return Version.parse('2.0.0')
def v130():
return Version.parse("1.3.0")
def v234():
return Version.parse('2.3.4')
def v200():
return Version.parse("2.0.0")
def v250():
return Version.parse('2.5.0')
def v250():
return Version.parse("2.5.0")
def v300():
return Version.parse('3.0.0')
def v003():
return Version.parse("0.0.3")
def v003():
return Version.parse('0.0.3')
def v072():
return Version.parse("0.7.2")
def v123():
return Version.parse("1.2.3")
def dependency_from_pep_508(name):
# Removing comments
parts = name.split("#", 1)
name = parts[0].strip()
if len(parts) > 1:
rest = parts[1]
if ";" in rest:
name += ";" + rest.split(";", 1)[1]
req = Requirement(name)
if req.marker:
markers = convert_markers(req.marker)
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.".format(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(r"^(?P<namever>(?P<name>.+?)-(?P<ver>\d.*?))",
link.filename)
if not m:
raise ValueError("Invalid wheel name: {}".format(
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.in_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 += ".*"
elif op in ("<=", ">"):
parsed_version = Version.parse(version)
if parsed_version.precision == 1:
if op == "<=":
op = "<"
version = parsed_version.next_major.text
elif op == ">":
op = ">="
version = parsed_version.next_major.text
elif parsed_version.precision == 2:
if op == "<=":
op = "<"
version = parsed_version.next_minor.text
elif op == ">":
op = ">="
version = parsed_version.next_minor.text
elif op in ("in", "not in"):
versions = []
for v in re.split("[ ,]+", version):
split = v.split(".")
if len(split) in [1, 2]:
split.append("*")
op_ = "" if op == "in" else "!="
else:
op_ = "==" if op == "in" else "!="
versions.append(op_ + ".".join(split))
glue = " || " if op == "in" else ", "
if versions:
ands.append(glue.join(versions))
continue
ands.append("{}{}".format(op, version))
ors.append(" ".join(ands))
dep.python_versions = " || ".join(ors)
if req.marker:
dep.marker = req.marker
# Extras
for extra in req.extras:
dep.extras.append(extra)
return dep
def v114():
return Version.parse("1.1.4")
from poetry.semver import parse_constraint
from poetry.semver import Version
from poetry.semver import VersionRange
from poetry.semver import VersionUnion
@pytest.mark.parametrize(
"input,constraint",
[
("*", VersionRange()),
("*.*", VersionRange()),
("v*.*", VersionRange()),
("*.x.*", VersionRange()),
("x.X.x.*", VersionRange()),
# ('!=1.0.0', Constraint('!=', '1.0.0.0')),
(">1.0.0", VersionRange(min=Version(1, 0, 0))),
("<1.2.3", VersionRange(max=Version(1, 2, 3))),
("<=1.2.3", VersionRange(max=Version(1, 2, 3), include_max=True)),
(">=1.2.3", VersionRange(min=Version(1, 2, 3), include_min=True)),
("=1.2.3", Version(1, 2, 3)),
("1.2.3", Version(1, 2, 3)),
("=1.0", Version(1, 0, 0)),
("1.2.3b5", Version(1, 2, 3, pre="b5")),
(">= 1.2.3", VersionRange(min=Version(1, 2, 3), include_min=True)),
(">dev", VersionRange(min=Version(0, 0, pre="dev"))), # Issue 206
],
)
def test_parse_constraint(input, constraint):
assert parse_constraint(input) == constraint
def test_union():
v = Version.parse("1.2.3")
assert v.union(v) == v
result = v.union(Version.parse("0.8.0"))
assert result.allows(v)
assert result.allows(Version.parse("0.8.0"))
assert not result.allows(Version.parse("1.1.4"))
range = VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4"))
assert v.union(range) == range
union = Version.parse("1.1.4").union(
VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4"))
)
assert union == VersionRange(
Version.parse("1.1.4"), Version.parse("1.2.4"), include_min=True
)
result = v.union(VersionRange(Version.parse("0.0.3"), Version.parse("1.1.4")))
assert result.allows(v)
assert result.allows(Version.parse("0.1.0"))
def test_parse_constraint_multi_wilcard(input):
assert parse_constraint(input) == VersionUnion(
VersionRange(Version(2, 7, 0), Version(3, 0, 0), True, False),
VersionRange(Version(3, 2, 0), None, True, False),
)
def v010():
return Version.parse("0.1.0")
