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_create_venv_uses_patch_version_to_detect_compatibility_with_executable( manager, poetry, config, mocker, config_virtualenvs_path): if "VIRTUAL_ENV" in os.environ: del os.environ["VIRTUAL_ENV"] version = Version.parse(".".join(str(c) for c in sys.version_info[:3])) poetry.package.python_versions = "~{}".format(".".join( str(c) for c in (version.major, version.minor - 1, 0))) venv_name = manager.generate_env_name("simple-project", str(poetry.file.parent)) check_output = mocker.patch( "subprocess.check_output", side_effect=check_output_wrapper( Version.parse("{}.{}.0".format(version.major, version.minor - 1))), ) m = mocker.patch("poetry.utils.env.EnvManager.build_venv", side_effect=lambda *args, **kwargs: "") manager.create_venv(NullIO(), executable="python{}.{}".format( version.major, version.minor - 1)) assert check_output.called m.assert_called_with( config_virtualenvs_path / "{}-py{}.{}".format(venv_name, version.major, version.minor - 1), executable="python{}.{}".format(version.major, version.minor - 1), flags={"always-copy": False}, )
def test_create_venv_uses_patch_version_to_detect_compatibility( manager, poetry, config, mocker ): if "VIRTUAL_ENV" in os.environ: del os.environ["VIRTUAL_ENV"] version = Version.parse(".".join(str(c) for c in sys.version_info[:3])) poetry.package.python_versions = "^{}".format( ".".join(str(c) for c in sys.version_info[:3]) ) venv_name = manager.generate_env_name("simple-project", str(poetry.file.parent)) mocker.patch("sys.version_info", (version.major, version.minor, version.patch + 1)) check_output = mocker.patch( "poetry.utils._compat.subprocess.check_output", side_effect=check_output_wrapper(Version.parse("3.6.9")), ) m = mocker.patch( "poetry.utils.env.EnvManager.build_venv", side_effect=lambda *args, **kwargs: "" ) manager.create_venv(NullIO()) assert not check_output.called m.assert_called_with( Path( "/foo/virtualenvs/{}-py{}.{}".format( venv_name, version.major, version.minor ) ), executable=None, )
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))
def test_allows_all(): v = Version.parse("1.2.3") assert v.allows_all(v) assert not v.allows_all(Version.parse("0.0.3")) assert not v.allows_all( VersionRange(Version.parse("1.1.4"), Version.parse("1.2.4"))) assert not v.allows_all(VersionRange()) assert v.allows_all(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_python_constraint_from_marker( marker, ): # type: (BaseMarker) -> VersionConstraint python_marker = marker.only("python_version") if python_marker.is_any(): return VersionRange() if python_marker.is_empty(): return EmptyConstraint() markers = convert_markers(marker) 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)) return parse_constraint(" || ".join(ors))
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( "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 test_create_venv_uses_patch_version_to_detect_compatibility( manager, poetry, config, mocker): if "VIRTUAL_ENV" in os.environ: del os.environ["VIRTUAL_ENV"] version = Version.parse(".".join(str(c) for c in sys.version_info[:3])) poetry.package.python_versions = "^{}".format(".".join( str(c) for c in sys.version_info[:3])) venv_name = manager.generate_env_name("simple-project", str(poetry.file.parent)) mocker.patch( "poetry.utils._compat.subprocess.check_output", side_effect=["2.7.16" for _ in range(3)] + [f"{version.major}.{version.minor}.{version.patch + 1}"], ) m = mocker.patch("poetry.utils.env.EnvManager.build_venv", side_effect=lambda *args, **kwargs: "") manager.create_venv(NullIO()) m.assert_called_with( Path("{}/virtualenvs/{}-py{}.{}".format(config.get("cache-dir"), venv_name, version.major, version.minor)), executable="python3", )
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( Path("/foo/virtualenvs/{}-py3.7".format(venv_name)), executable="python3", flags={"always-copy": False}, )
def test_add_constraint_with_source(app, poetry, tester): repo = LegacyRepository(name="my-index", url="https://my-index.fake") repo.add_package(get_package("cachy", "0.2.0")) repo._cache.store("matches").put("cachy:0.2.0", [Version.parse("0.2.0")], 5) poetry.pool.add_repository(repo) tester.execute("cachy=0.2.0 --source my-index") expected = """\ Updating dependencies Resolving dependencies... Writing lock file Package operations: 1 install, 0 updates, 0 removals • Installing cachy (0.2.0) """ assert expected == tester.io.fetch_output() assert 1 == tester._command.installer.executor.installations_count content = app.poetry.file.read()["tool"]["poetry"] assert "cachy" in content["dependencies"] assert content["dependencies"]["cachy"] == { "version": "0.2.0", "source": "my-index", }
def handle(self): from poetry.__version__ import __version__ from poetry.core.semver import Version from poetry.utils.env import EnvManager new_update_method = False try: self._check_recommended_installation() except RuntimeError as e: env = EnvManager.get_system_env(naive=True) try: env.path.relative_to(self.data_dir) except ValueError: raise e new_update_method = True version = self.argument("version") if not version: version = ">=" + __version__ repo = self.pool.repositories[0] packages = repo.find_packages( Dependency("poetry", version, allows_prereleases=self.option("preview"))) if not packages: self.line("No release found for the specified version") return packages.sort(key=cmp_to_key(lambda x, y: 0 if x.version == y.version else int(x.version < y.version or -1))) release = None for package in packages: if package.is_prerelease(): if self.option("preview"): release = package break continue release = package break if release is None: self.line("No new release found") return if release.version == Version.parse(__version__): self.line("You are using the latest version") return if new_update_method: return self.update_with_new_method(release.version) self.update(release)
def mock_subprocess_calls(setup, current_python, mocker): mocker.patch( "subprocess.check_output", side_effect=check_output_wrapper(Version(*current_python)), ) mocker.patch( "subprocess.Popen.communicate", side_effect=[("/prefix", None), ("/prefix", None), ("/prefix", None)], )
def check_output_wrapper(version=Version.parse("3.7.1")): def check_output(cmd, *args, **kwargs): if "sys.version_info[:3]" in cmd: return version.text elif "sys.version_info[:2]" in cmd: return "{}.{}".format(version.major, version.minor) else: return str(Path("/prefix")) return check_output
def test_deactivate_activated(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)) version = Version.parse(".".join(str(c) for c in sys.version_info[:3])) other_version = Version.parse("3.4") if version.major == 2 else version.next_minor ( Path(tmp_dir) / "{}-py{}.{}".format(venv_name, version.major, version.minor) ).mkdir() ( Path(tmp_dir) / "{}-py{}.{}".format(venv_name, other_version.major, other_version.minor) ).mkdir() envs_file = TOMLFile(Path(tmp_dir) / "envs.toml") doc = tomlkit.document() doc[venv_name] = { "minor": "{}.{}".format(other_version.major, other_version.minor), "patch": other_version.text, } envs_file.write(doc) config.merge({"virtualenvs": {"path": str(tmp_dir)}}) mocker.patch( "poetry.utils._compat.subprocess.check_output", side_effect=check_output_wrapper(), ) manager.deactivate(NullIO()) env = manager.get() assert env.path == Path(tmp_dir) / "{}-py{}.{}".format( venv_name, version.major, version.minor ) assert Path("/prefix") envs = envs_file.read() assert len(envs) == 0
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._maintainers = [] self.homepage = None self.repository_url = None self.documentation_url = None self.keywords = [] self._license = None self.readme = None self.source_name = "" self.source_type = "" self.source_reference = "" self.source_url = "" self.requires = [] self.dev_requires = [] self.extras = {} self.requires_extras = [] self.category = "main" self.files = [] self.optional = False self.classifiers = [] self._python_versions = "*" self._python_constraint = parse_constraint("*") self._python_marker = AnyMarker() self.platform = None self.marker = AnyMarker() self.root_dir = None self.develop = True
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): # type: (str, str) -> "Version" from poetry.core.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 handle(self): # type: () -> None from poetry.__version__ import __version__ from poetry.core.semver import Version from poetry.repositories.pypi_repository import PyPiRepository self._check_recommended_installation() version = self.argument("version") if not version: version = ">=" + __version__ repo = PyPiRepository(fallback=False) packages = repo.find_packages( Dependency("poetry", version, allows_prereleases=self.option("preview")) ) if not packages: self.line("No release found for the specified version") return packages.sort( key=cmp_to_key( lambda x, y: 0 if x.version == y.version else int(x.version < y.version or -1) ) ) release = None for package in packages: if package.is_prerelease(): if self.option("preview"): release = package break continue release = package break if release is None: self.line("No new release found") return if release.version == Version.parse(__version__): self.line("You are using the latest version") return self.update(release)
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 test_get_prefers_explicitly_activated_non_existing_virtualenvs_over_env_var( app, tmp_dir, mocker ): mocker.stopall() 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]) app.poetry.config.merge({"virtualenvs": {"path": str(tmp_dir)}}) mocker.patch( "poetry.utils.env.EnvManager._env", new_callable=mocker.PropertyMock, return_value=MockEnv( path=Path("/environment/prefix"), base=Path("/base/prefix"), version_info=current_python, is_venv=True, ), ) 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)], ) mocker.patch("poetry.utils.env.EnvManager.build_venv", side_effect=build_venv) command = app.find("env use") tester = CommandTester(command) tester.execute(python_minor) expected = """\ Creating virtualenv {} in {} Using virtualenv: {} """.format( "{}-py{}".format(venv_name, python_minor), tmp_dir, os.path.join(tmp_dir, "{}-py{}".format(venv_name, python_minor)), ) assert expected == tester.io.fetch_output()
def test_remove_keeps_dir_if_not_deleteable(tmp_dir, manager, poetry, config, mocker): # Ensure we empty rather than delete folder if its is an active mount point. # See https://github.com/python-poetry/poetry/pull/2064 config.merge({"virtualenvs": {"path": str(tmp_dir)}}) venv_name = manager.generate_env_name("simple-project", str(poetry.file.parent)) venv_path = Path(tmp_dir) / "{}-py3.6".format(venv_name) venv_path.mkdir() folder1_path = venv_path / "folder1" folder1_path.mkdir() file1_path = folder1_path / "file1" file1_path.touch(exist_ok=False) file2_path = venv_path / "file2" file2_path.touch(exist_ok=False) mocker.patch( "poetry.utils._compat.subprocess.check_output", side_effect=check_output_wrapper(Version.parse("3.6.6")), ) original_rmtree = shutil.rmtree def err_on_rm_venv_only(path, *args, **kwargs): print(path) if path == str(venv_path): raise OSError(16, "Test error") # ERRNO 16: Device or resource busy else: original_rmtree(path) m = mocker.patch("shutil.rmtree", side_effect=err_on_rm_venv_only) venv = manager.remove("{}-py3.6".format(venv_name)) m.assert_any_call(str(venv_path)) assert venv_path == venv.path assert venv_path.exists() assert not folder1_path.exists() assert not file1_path.exists() assert not file2_path.exists() m.side_effect = original_rmtree # Avoid teardown using `err_on_rm_venv_only`
def read_setup_cfg( self, filepath ): # type: (Union[str, Path]) -> Dict[str, Union[List, Dict]] parser = ConfigParser() parser.read(str(filepath)) name = None version = None if parser.has_option("metadata", "name"): name = parser.get("metadata", "name") if parser.has_option("metadata", "version"): version = Version.parse(parser.get("metadata", "version")).text install_requires = [] extras_require = {} python_requires = None if parser.has_section("options"): if parser.has_option("options", "install_requires"): for dep in parser.get("options", "install_requires").split("\n"): dep = dep.strip() if not dep: continue install_requires.append(dep) if parser.has_option("options", "python_requires"): python_requires = parser.get("options", "python_requires") if parser.has_section("options.extras_require"): for group in parser.options("options.extras_require"): extras_require[group] = [] deps = parser.get("options.extras_require", group) for dep in deps.split("\n"): dep = dep.strip() if not dep: continue extras_require[group].append(dep) return { "name": name, "version": version, "install_requires": install_requires, "extras_require": extras_require, "python_requires": python_requires, }
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 test_remove_by_name(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")), ) venv = manager.remove("{}-py3.6".format(venv_name)) assert (Path(tmp_dir) / "{}-py3.6".format(venv_name)) == venv.path assert not (Path(tmp_dir) / "{}-py3.6".format(venv_name)).exists()
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 = PackageInfo( name=name, version=version, summary="", platform=None, requires_dist=[], requires_python=None, files=[], cache_version=str(self.CACHE_VERSION), ) 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 = defaultdict(list) files = [] for link in links: if link.is_wheel: urls["bdist_wheel"].append(link.url) elif link.filename.endswith( (".tar.gz", ".zip", ".bz2", ".xz", ".Z", ".tar") ): urls["sdist"].append(link.url) h = link.hash if h: h = link.hash_name + ":" + link.hash files.append({"file": link.filename, "hash": h}) data.files = files 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.asdict()
def test_activate_does_not_recreate_when_switching_minor( 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.0"} envs_file.write(doc) os.mkdir(os.path.join(tmp_dir, "{}-py3.7".format(venv_name))) os.mkdir(os.path.join(tmp_dir, "{}-py3.6".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)], ) build_venv_m = mocker.patch( "poetry.utils.env.EnvManager.build_venv", side_effect=build_venv ) remove_venv_m = mocker.patch( "poetry.utils.env.EnvManager.remove_venv", side_effect=EnvManager.remove_venv ) env = manager.activate("python3.6", NullIO()) build_venv_m.assert_not_called() remove_venv_m.assert_not_called() 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") assert (Path(tmp_dir) / "{}-py3.6".format(venv_name)).exists()
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 _transform_version(self, version, pretty_version): try: parsed = Version.parse(version) parts = [parsed.major, parsed.minor, parsed.patch] except ValueError: return pretty_version parts = parts[: parsed.precision] # check to see if we have a semver-looking version if len(parts) < 3: version = pretty_version else: version = ".".join(str(p) for p in parts) if parsed.is_prerelease(): version += "-{}".format(".".join(str(p) for p in parsed.prerelease)) return "^{}".format(version)
def test_get_prefers_explicitly_activated_virtualenvs_over_env_var( app, tmp_dir, mocker ): mocker.stopall() 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) app.poetry.config.merge({"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()