def get_versions(self):
versions = defaultdict(VersionPath)
bin_ = sysconfig._INSTALL_SCHEMES[
sysconfig._get_default_scheme()]["scripts"]
for p in self.root.glob("versions/*"):
if p.parent.name == "envs":
continue
try:
version = PythonVersion.parse(p.name)
except ValueError:
bin_dir = Path(bin_.format(base=p.as_posix()))
if bin_dir.exists():
version = self.version_from_bin_dir(bin_dir)
if not version:
if not self.ignore_unsupported:
raise
continue
except Exception:
if not self.ignore_unsupported:
raise
logger.warning('Unsupported Python version %r, ignoring...',
p.name,
exc_info=True)
continue
if not version:
continue
version_tuple = (version.get("major"), version.get("minor"),
version.get("patch"),
version.get("is_prerelease"),
version.get("is_devrelease"),
version.get("is_debug"))
versions[version_tuple] = VersionPath.create(path=p.resolve(),
only_python=True)
return versions
def test_update(
capsys, tmp_path, shared_datadir, source_pipfile_dirname, update_count
): # type: (Any, Path, Path, str, int) -> None
"""
test updating setup.py (when it already exists)
"""
pipfile_dir = shared_datadir / source_pipfile_dirname
for filename in ("Pipfile", "Pipfile.lock", "setup.py"):
copy_file(pipfile_dir / filename, tmp_path)
with data(source_pipfile_dirname, tmp_path):
cmd(argv=["", "sync"])
generated_setup = Path("setup.py")
assert generated_setup.exists()
generated_setup_text = generated_setup.read_text()
expected_setup_text = Path("setup.py").read_text()
for kw_arg_names in ("install_requires", "dependency_links"):
assert compare_list_of_string_kw_arg(
generated_setup_text,
expected_setup_text,
kw_arg_names,
ordering_matters=False,
)
captured = capsys.readouterr()
assert msg_formatter.update_success(update_count) in captured.out
def test_only_setup_missing(
capsys, tmp_path, shared_datadir, source_pipfile_dirname, update_count
): # type: (Any, Path, Path, str, int) -> None
"""
test generate setup.py (when it is missing)
"""
pipfile_dir = shared_datadir / source_pipfile_dirname
with data(source_pipfile_dirname, tmp_path):
# delete the setup.py file that was copied to the tmp_path
(tmp_path / "setup.py").unlink()
cmd(argv=["", "sync"])
generated_setup = Path("setup.py")
assert generated_setup.exists()
generated_setup_text = generated_setup.read_text()
expected_setup_text = Path("setup.py").read_text()
for kw_arg_names in ("install_requires", "dependency_links"):
assert compare_list_of_string_kw_arg(
generated_setup_text,
expected_setup_text,
kw_arg_names,
ordering_matters=False,
)
captured = capsys.readouterr()
assert msg_formatter.generate_success(update_count) in captured.out, captured.out
def test_sync_pipfile_no_original(capsys, tmp_path, shared_datadir,
source_pipfile_dirname, update_count):
"""
sync --pipfile should reference Pipfile (not Pipfile.lock) when printing results
"""
pipfile_dir = shared_datadir / source_pipfile_dirname
for filename in ("Pipfile", "Pipfile.lock", "setup.py"):
copy_file(pipfile_dir / filename, tmp_path)
with data(str(pipfile_dir), tmp_path) as path:
setup_file = path / "setup.py" # type: Path
cmd(["", "sync", "--pipfile"])
text = setup_file.read_text()
generated_setup = Path("setup.py")
assert generated_setup.exists()
generated_setup_text = generated_setup.read_text()
expected_setup_text = Path("setup.py").read_text()
for kw_arg_names in ("install_requires", "dependency_links"):
assert compare_list_of_string_kw_arg(
generated_setup_text,
expected_setup_text,
kw_arg_names,
ordering_matters=False,
)
captured = capsys.readouterr()
assert "Pipfile.lock" not in captured.out, captured.out
assert "Pipfile" in captured.out, captured.out
def ensure_setup_py(base_dir):
if not base_dir:
base_dir = create_tracked_tempdir(prefix="requirementslib-setup")
base_dir = Path(base_dir)
if base_dir.exists() and base_dir.name == "setup.py":
base_dir = base_dir.parent
elif not (base_dir.exists() and base_dir.is_dir()):
base_dir = base_dir.parent
if not (base_dir.exists() and base_dir.is_dir()):
base_dir = base_dir.parent
setup_py = base_dir.joinpath("setup.py")
is_new = False if setup_py.exists() else True
if not setup_py.exists():
setup_py.write_text(u"")
try:
yield
finally:
if is_new:
setup_py.unlink()
def load(cls, path):
if not path:
path = os.curdir
path = Path(path).absolute()
if path.is_dir():
path = path / "Pipfile.lock"
elif path.name == "Pipfile":
path = path.parent / "Pipfile.lock"
if not path.exists():
raise OSError("Path does not exist: %s" % path)
return cls.create(path.parent, lockfile_name=path.name)
def get_versions(self):
versions = defaultdict()
bin_ = sysconfig._INSTALL_SCHEMES[
sysconfig._get_default_scheme()]["scripts"]
for p in self.root.glob("versions/*"):
if p.parent.name == "envs" or p.name == "envs":
continue
bin_dir = Path(bin_.format(base=p.as_posix()))
version_path = None
if bin_dir.exists():
version_path = PathEntry.create(
path=bin_dir.absolute().as_posix(),
only_python=False,
name=p.name,
is_root=True,
)
version = None
try:
version = PythonVersion.parse(p.name)
except ValueError:
entry = next(iter(version_path.find_all_python_versions()),
None)
if not entry:
if self.ignore_unsupported:
continue
raise
else:
version = entry.py_version.as_dict()
except Exception:
if not self.ignore_unsupported:
raise
logger.warning("Unsupported Python version %r, ignoring...",
p.name,
exc_info=True)
continue
if not version:
continue
version_tuple = (
version.get("major"),
version.get("minor"),
version.get("patch"),
version.get("is_prerelease"),
version.get("is_devrelease"),
version.get("is_debug"),
)
self.roots[p] = version_path
versions[version_tuple] = version_path
self.paths.append(version_path)
return versions
def get_versions(self):
from .path import PathEntry
versions = defaultdict()
bin_ = "{base}/bin"
for p in self.get_version_order():
bin_dir = Path(bin_.format(base=p.as_posix()))
version_path = None
if bin_dir.exists():
version_path = PathEntry.create(
path=bin_dir.absolute().as_posix(),
only_python=False,
name=p.name,
is_root=True,
)
version = None
try:
version = PythonVersion.parse(p.name)
except (ValueError, InvalidPythonVersion):
entry = next(iter(version_path.find_all_python_versions()),
None)
if not entry:
if self.ignore_unsupported:
continue
raise
else:
version = entry.py_version.as_dict()
except Exception:
if not self.ignore_unsupported:
raise
logger.warning("Unsupported Python version %r, ignoring...",
p.name,
exc_info=True)
continue
if not version:
continue
version_tuple = (
version.get("major"),
version.get("minor"),
version.get("patch"),
version.get("is_prerelease"),
version.get("is_devrelease"),
version.get("is_debug"),
)
self.roots[p] = version_path
versions[version_tuple] = version_path
self.paths.append(version_path)
return versions
def load(cls, path):
if not isinstance(path, Path):
path = Path(path)
pipfile_path = path / "Pipfile"
if not path.exists():
raise FileNotFoundError("%s is not a valid project path!" % path)
elif not pipfile_path.exists() or not pipfile_path.is_file():
raise RequirementError("%s is not a valid Pipfile" % pipfile_path)
with pipfile_path.open(encoding="utf-8") as fp:
pipfile = super(Pipfile, cls).load(fp)
pipfile.dev_requirements = [
Requirement.from_pipfile(k, v) for k, v in pipfile.dev_packages.items()
]
pipfile.requirements = [
Requirement.from_pipfile(k, v) for k, v in pipfile.packages.items()
]
pipfile.path = pipfile_path
return pipfile
def test_generation(tmp_path, shared_datadir,
source_pipfile_dirname): # type: (Path, Path, str) -> None
"""
test boilerplate
"""
pipfile_dir = shared_datadir / source_pipfile_dirname
copy_pipfiles(pipfile_dir, tmp_path)
with data(source_pipfile_dirname, tmp_path):
cmd(argv=["", "sync"])
generated_setup = Path("setup.py")
assert generated_setup.exists()
generated_setup_text = generated_setup.read_text()
expected_setup_text = Path("setup.py").read_text()
for kw_arg_names in ("install_requires", "dependency_links"):
assert compare_list_of_string_kw_arg(
generated_setup_text,
expected_setup_text,
kw_arg_names,
ordering_matters=False,
)
