def test_wheel_prerelease():
module_path = fixtures_dir / "prerelease"
WheelBuilder.make(Factory().create_poetry(module_path))
whl = module_path / "dist" / "prerelease-0.1b1-py2.py3-none-any.whl"
assert whl.exists()
def test_default_src_with_excluded_data(mocker):
# Patch git module to return specific excluded files
p = mocker.patch("poetry.core.vcs.git.Git.get_ignored_files")
p.return_value = [
((Path(__file__).parent / "fixtures" /
"default_src_with_excluded_data" / "src" / "my_package" / "data" /
"sub_data" / "data2.txt").relative_to(
project("default_src_with_excluded_data")).as_posix())
]
poetry = Factory().create_poetry(project("default_src_with_excluded_data"))
builder = WheelBuilder(poetry)
builder.build()
whl = (fixtures_dir / "default_src_with_excluded_data" / "dist" /
"my_package-1.2.3-py3-none-any.whl")
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
names = z.namelist()
assert "my_package/__init__.py" in names
assert "my_package/data/data1.txt" in names
assert "my_package/data/sub_data/data2.txt" not in names
assert "my_package/data/sub_data/data3.txt" in names
def test_wheel_package_pep_561_stub_only_includes_typed_marker():
root = fixtures_dir / "pep_561_stub_only_partial"
WheelBuilder.make(Factory().create_poetry(root))
whl = root / "dist" / "pep_561_stubs-0.1-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "pkg-stubs/py.typed" in z.namelist()
def test_wheel_module():
module_path = fixtures_dir / "module1"
WheelBuilder.make(Factory().create_poetry(module_path))
whl = module_path / "dist" / "module1-0.1-py2.py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "module1.py" in z.namelist()
def test_wheel_package():
module_path = fixtures_dir / "complete"
WheelBuilder.make(Factory().create_poetry(module_path))
whl = module_path / "dist" / "my_package-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "my_package/sub_pkg1/__init__.py" in z.namelist()
def test_wheel_includes_inline_table():
module_path = fixtures_dir / "with_include_inline_table"
WheelBuilder.make(Factory().create_poetry(module_path))
whl = module_path / "dist" / "with_include-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "wheel_only.txt" in z.namelist()
assert "notes.txt" not in z.namelist()
def test_wheel_package_src():
module_path = fixtures_dir / "source_package"
WheelBuilder.make(Factory().create_poetry(module_path))
whl = module_path / "dist" / "package_src-0.1-py2.py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "package_src/__init__.py" in z.namelist()
assert "package_src/module.py" in z.namelist()
def test_wheel_localversionlabel():
module_path = fixtures_dir / "localversionlabel"
project = Factory().create_poetry(module_path)
WheelBuilder.make(project)
local_version_string = "localversionlabel-0.1b1+gitbranch.buildno.1"
whl = module_path / "dist" / (local_version_string + "-py2.py3-none-any.whl")
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert local_version_string + ".dist-info/METADATA" in z.namelist()
def test_wheel_with_file_with_comma():
root = fixtures_dir / "comma_file"
WheelBuilder.make(Factory().create_poetry(root))
whl = root / "dist" / "comma_file-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
records = z.read("comma_file-1.2.3.dist-info/RECORD")
assert '\n"comma_file/a,b.py"' in records.decode()
def test_wheel_package_pep_561_stub_only(package):
root = fixtures_dir / package
WheelBuilder.make(Factory().create_poetry(root))
whl = root / "dist" / "pep_561_stubs-0.1-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "pkg-stubs/__init__.pyi" in z.namelist()
assert "pkg-stubs/module.pyi" in z.namelist()
assert "pkg-stubs/subpkg/__init__.pyi" in z.namelist()
def test_include_excluded_code():
module_path = fixtures_dir / "include_excluded_code"
poetry = Factory().create_poetry(module_path)
wb = WheelBuilder(poetry)
wb.build()
whl = module_path / "dist" / wb.wheel_filename
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "my_package/__init__.py" in z.namelist()
assert "my_package/generated.py" in z.namelist()
assert "lib/my_package/generated.py" not in z.namelist()
def test_wheel_excluded_data():
module_path = fixtures_dir / "default_with_excluded_data_toml"
WheelBuilder.make(Factory().create_poetry(module_path))
whl = module_path / "dist" / "my_package-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "my_package/__init__.py" in z.namelist()
assert "my_package/data/sub_data/data2.txt" in z.namelist()
assert "my_package/data/sub_data/data3.txt" in z.namelist()
assert "my_package/data/data1.txt" not in z.namelist()
def test_wheel_includes_licenses_in_correct_paths():
root = fixtures_dir / "licenses_and_copying"
WheelBuilder.make(Factory().create_poetry(root))
whl = root / "dist" / "my_package-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "my_package-1.2.3.dist-info/COPYING" in z.namelist()
assert "my_package-1.2.3.dist-info/COPYING.txt" in z.namelist()
assert "my_package-1.2.3.dist-info/LICENSE" in z.namelist()
assert "my_package-1.2.3.dist-info/LICENSE.md" in z.namelist()
assert "my_package-1.2.3.dist-info/LICENSES/CUSTOM-LICENSE" in z.namelist()
assert "my_package-1.2.3.dist-info/LICENSES/BSD-3.md" in z.namelist()
assert "my_package-1.2.3.dist-info/LICENSES/MIT.txt" in z.namelist()
def test_dist_info_file_permissions():
module_path = fixtures_dir / "complete"
WheelBuilder.make(Factory().create_poetry(module_path))
whl = module_path / "dist" / "my_package-1.2.3-py3-none-any.whl"
with zipfile.ZipFile(str(whl)) as z:
assert (z.getinfo("my_package-1.2.3.dist-info/WHEEL").external_attr ==
0o644 << 16)
assert (z.getinfo("my_package-1.2.3.dist-info/METADATA").external_attr
== 0o644 << 16)
assert (z.getinfo("my_package-1.2.3.dist-info/RECORD").external_attr ==
0o644 << 16)
assert (z.getinfo("my_package-1.2.3.dist-info/entry_points.txt").
external_attr == 0o644 << 16)
def build_editable(
wheel_directory: str,
config_settings: dict[str, Any] | None = None,
metadata_directory: str | None = None,
) -> str:
poetry = Factory().create_poetry(Path(".").resolve(), with_groups=False)
return WheelBuilder.make_in(poetry, Path(wheel_directory), editable=True)
def build_wheel(
wheel_directory: str,
config_settings: dict[str, Any] | None = None,
metadata_directory: str | None = None,
) -> str:
"""Builds a wheel, places it in wheel_directory"""
poetry = Factory().create_poetry(Path(".").resolve(), with_groups=False)
return WheelBuilder.make_in(poetry, Path(wheel_directory))
def test_wheel_file_is_closed(monkeypatch):
"""Confirm that wheel zip files are explicitly closed."""
# Using a list is a hack for Python 2.7 compatibility.
fd_file = [None]
real_fdopen = os.fdopen
def capturing_fdopen(*args, **kwargs):
fd_file[0] = real_fdopen(*args, **kwargs)
return fd_file[0]
monkeypatch.setattr(os, "fdopen", capturing_fdopen)
module_path = fixtures_dir / "module1"
WheelBuilder.make(Factory().create_poetry(module_path))
assert fd_file[0] is not None
assert fd_file[0].closed
def test_wheel_excluded_nested_data():
module_path = fixtures_dir / "exclude_nested_data_toml"
poetry = Factory().create_poetry(module_path)
WheelBuilder.make(poetry)
whl = module_path / "dist" / "my_package-1.2.3-py3-none-any.whl"
assert whl.exists()
with zipfile.ZipFile(str(whl)) as z:
assert "my_package/__init__.py" in z.namelist()
assert "my_package/data/sub_data/data2.txt" not in z.namelist()
assert "my_package/data/sub_data/data3.txt" not in z.namelist()
assert "my_package/data/data1.txt" not in z.namelist()
assert "my_package/data/data2.txt" in z.namelist()
assert "my_package/puplic/publicdata.txt" in z.namelist()
assert "my_package/public/item1/itemdata1.txt" not in z.namelist()
assert "my_package/public/item1/subitem/subitemdata.txt" not in z.namelist()
assert "my_package/public/item2/itemdata2.txt" not in z.namelist()
def _install_package(poetry, env, io):
"Install package."
with temporary_directory() as directory:
wheel_name = WheelBuilder.make_in(poetry, directory=Path(directory))
wheel = Path(directory).joinpath(wheel_name)
package = Package(
poetry.package.name,
poetry.package.version,
source_type="file",
source_url=wheel,
)
_make_installer(poetry, env, io).executor.execute([Install(package)])
def _add_dist_info(self, added_files: List[Path]) -> None:
from poetry.core.masonry.builders.wheel import WheelBuilder
added_files = added_files[:]
builder = WheelBuilder(self._poetry)
dist_info_path = Path(builder.dist_info)
for dist_info in self._env.site_packages.find(
dist_info_path, writable_only=True
):
if dist_info.exists():
self._debug(
" - Removing existing <c2>{}</c2> directory from <b>{}</b>".format(
dist_info.name, dist_info.parent
)
)
shutil.rmtree(str(dist_info))
dist_info = self._env.site_packages.mkdir(dist_info_path)
self._debug(
" - Adding the <c2>{}</c2> directory to <b>{}</b>".format(
dist_info.name, dist_info.parent
)
)
with dist_info.joinpath("METADATA").open("w", encoding="utf-8") as f:
builder._write_metadata_file(f)
added_files.append(dist_info.joinpath("METADATA"))
with dist_info.joinpath("INSTALLER").open("w", encoding="utf-8") as f:
f.write("poetry")
added_files.append(dist_info.joinpath("INSTALLER"))
if self.convert_entry_points():
with dist_info.joinpath("entry_points.txt").open(
"w", encoding="utf-8"
) as f:
builder._write_entry_points(f)
added_files.append(dist_info.joinpath("entry_points.txt"))
with dist_info.joinpath("RECORD").open("w", encoding="utf-8") as f:
for path in added_files:
hash = self._get_file_hash(path)
size = path.stat().st_size
f.write("{},sha256={},{}\n".format(str(path), hash, size))
# RECORD itself is recorded with no hash or size
f.write("{},,\n".format(dist_info.joinpath("RECORD")))
def prepare_metadata_for_build_wheel(
metadata_directory: str, config_settings: dict[str, Any] | None = None
) -> str:
poetry = Factory().create_poetry(Path(".").resolve(), with_groups=False)
builder = WheelBuilder(poetry)
dist_info = Path(metadata_directory, builder.dist_info)
dist_info.mkdir(parents=True, exist_ok=True)
if "scripts" in poetry.local_config or "plugins" in poetry.local_config:
with (dist_info / "entry_points.txt").open("w", encoding="utf-8") as f:
builder._write_entry_points(f)
with (dist_info / "WHEEL").open("w", encoding="utf-8") as f:
builder._write_wheel_file(f)
with (dist_info / "METADATA").open("w", encoding="utf-8") as f:
builder._write_metadata_file(f)
return dist_info.name
def _add_dist_info(self, added_files: list[Path]) -> None:
from poetry.core.masonry.builders.wheel import WheelBuilder
added_files = added_files[:]
builder = WheelBuilder(self._poetry)
dist_info = self._env.site_packages.mkdir(Path(builder.dist_info))
self._debug(f" - Adding the <c2>{dist_info.name}</c2> directory to"
f" <b>{dist_info.parent}</b>")
with dist_info.joinpath("METADATA").open("w", encoding="utf-8") as f:
builder._write_metadata_file(f)
added_files.append(dist_info.joinpath("METADATA"))
with dist_info.joinpath("INSTALLER").open("w", encoding="utf-8") as f:
f.write("poetry")
added_files.append(dist_info.joinpath("INSTALLER"))
if self.convert_entry_points():
with dist_info.joinpath("entry_points.txt").open(
"w", encoding="utf-8") as f:
builder._write_entry_points(f)
added_files.append(dist_info.joinpath("entry_points.txt"))
# write PEP 610 metadata
direct_url_json = dist_info.joinpath("direct_url.json")
direct_url_json.write_text(
json.dumps({
"dir_info": {
"editable": True
},
"url": self._poetry.file.path.parent.as_uri(),
}))
added_files.append(direct_url_json)
record = dist_info.joinpath("RECORD")
with record.open("w", encoding="utf-8", newline="") as f:
csv_writer = csv.writer(f)
for path in added_files:
hash = self._get_file_hash(path)
size = path.stat().st_size
csv_writer.writerow((path, f"sha256={hash}", size))
# RECORD itself is recorded with no hash or size
csv_writer.writerow((record, "", ""))
def _add_dist_info(self, added_files: List[Path]) -> None:
from poetry.core.masonry.builders.wheel import WheelBuilder
added_files = added_files[:]
builder = WheelBuilder(self._poetry)
dist_info = self._env.site_packages.mkdir(Path(builder.dist_info))
self._debug(
f" - Adding the <c2>{dist_info.name}</c2> directory to"
f" <b>{dist_info.parent}</b>"
)
with dist_info.joinpath("METADATA").open("w", encoding="utf-8") as f:
builder._write_metadata_file(f)
added_files.append(dist_info.joinpath("METADATA"))
with dist_info.joinpath("INSTALLER").open("w", encoding="utf-8") as f:
f.write("poetry")
added_files.append(dist_info.joinpath("INSTALLER"))
if self.convert_entry_points():
with dist_info.joinpath("entry_points.txt").open(
"w", encoding="utf-8"
) as f:
builder._write_entry_points(f)
added_files.append(dist_info.joinpath("entry_points.txt"))
record = dist_info.joinpath("RECORD")
with record.open("w", encoding="utf-8") as f:
for path in added_files:
hash = self._get_file_hash(path)
size = path.stat().st_size
f.write(f"{path!s},sha256={hash},{size}\n")
# RECORD itself is recorded with no hash or size
f.write(f"{record},,\n")
