juc500 정상동작
This commit is contained in:
Macbook
@@ -0,0 +1,169 @@
|
||||
"""
|
||||
Wheel command-line utility.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import os
|
||||
import sys
|
||||
from argparse import ArgumentTypeError
|
||||
|
||||
from ..wheelfile import WheelError
|
||||
|
||||
|
||||
def unpack_f(args: argparse.Namespace) -> None:
|
||||
from .unpack import unpack
|
||||
|
||||
unpack(args.wheelfile, args.dest)
|
||||
|
||||
|
||||
def pack_f(args: argparse.Namespace) -> None:
|
||||
from .pack import pack
|
||||
|
||||
pack(args.directory, args.dest_dir, args.build_number)
|
||||
|
||||
|
||||
def convert_f(args: argparse.Namespace) -> None:
|
||||
from .convert import convert
|
||||
|
||||
convert(args.files, args.dest_dir, args.verbose)
|
||||
|
||||
|
||||
def tags_f(args: argparse.Namespace) -> None:
|
||||
from .tags import tags
|
||||
|
||||
names = (
|
||||
tags(
|
||||
wheel,
|
||||
args.python_tag,
|
||||
args.abi_tag,
|
||||
args.platform_tag,
|
||||
args.build,
|
||||
args.remove,
|
||||
)
|
||||
for wheel in args.wheel
|
||||
)
|
||||
|
||||
for name in names:
|
||||
print(name)
|
||||
|
||||
|
||||
def info_f(args: argparse.Namespace) -> None:
|
||||
from .info import info
|
||||
|
||||
try:
|
||||
info(args.wheelfile, args.verbose)
|
||||
except FileNotFoundError as e:
|
||||
raise WheelError(str(e)) from e
|
||||
|
||||
|
||||
def version_f(args: argparse.Namespace) -> None:
|
||||
from .. import __version__
|
||||
|
||||
print(f"wheel {__version__}")
|
||||
|
||||
|
||||
def parse_build_tag(build_tag: str) -> str:
|
||||
if build_tag and not build_tag[0].isdigit():
|
||||
raise ArgumentTypeError("build tag must begin with a digit")
|
||||
elif "-" in build_tag:
|
||||
raise ArgumentTypeError("invalid character ('-') in build tag")
|
||||
|
||||
return build_tag
|
||||
|
||||
|
||||
TAGS_HELP = """\
|
||||
Make a new wheel with given tags. Any tags unspecified will remain the same.
|
||||
Starting the tags with a "+" will append to the existing tags. Starting with a
|
||||
"-" will remove a tag (use --option=-TAG syntax). Multiple tags can be
|
||||
separated by ".". The original file will remain unless --remove is given. The
|
||||
output filename(s) will be displayed on stdout for further processing.
|
||||
"""
|
||||
|
||||
|
||||
def parser() -> argparse.ArgumentParser:
|
||||
p = argparse.ArgumentParser()
|
||||
s = p.add_subparsers(help="commands")
|
||||
|
||||
unpack_parser = s.add_parser("unpack", help="Unpack wheel")
|
||||
unpack_parser.add_argument(
|
||||
"--dest", "-d", help="Destination directory", default="."
|
||||
)
|
||||
unpack_parser.add_argument("wheelfile", help="Wheel file")
|
||||
unpack_parser.set_defaults(func=unpack_f)
|
||||
|
||||
repack_parser = s.add_parser("pack", help="Repack wheel")
|
||||
repack_parser.add_argument("directory", help="Root directory of the unpacked wheel")
|
||||
repack_parser.add_argument(
|
||||
"--dest-dir",
|
||||
"-d",
|
||||
default=os.path.curdir,
|
||||
help="Directory to store the wheel (default %(default)s)",
|
||||
)
|
||||
repack_parser.add_argument(
|
||||
"--build-number", help="Build tag to use in the wheel name"
|
||||
)
|
||||
repack_parser.set_defaults(func=pack_f)
|
||||
|
||||
convert_parser = s.add_parser("convert", help="Convert egg or wininst to wheel")
|
||||
convert_parser.add_argument("files", nargs="*", help="Files to convert")
|
||||
convert_parser.add_argument(
|
||||
"--dest-dir",
|
||||
"-d",
|
||||
default=os.path.curdir,
|
||||
help="Directory to store wheels (default %(default)s)",
|
||||
)
|
||||
convert_parser.add_argument("--verbose", "-v", action="store_true")
|
||||
convert_parser.set_defaults(func=convert_f)
|
||||
|
||||
tags_parser = s.add_parser(
|
||||
"tags", help="Add or replace the tags on a wheel", description=TAGS_HELP
|
||||
)
|
||||
tags_parser.add_argument("wheel", nargs="*", help="Existing wheel(s) to retag")
|
||||
tags_parser.add_argument(
|
||||
"--remove",
|
||||
action="store_true",
|
||||
help="Remove the original files, keeping only the renamed ones",
|
||||
)
|
||||
tags_parser.add_argument(
|
||||
"--python-tag", metavar="TAG", help="Specify an interpreter tag(s)"
|
||||
)
|
||||
tags_parser.add_argument("--abi-tag", metavar="TAG", help="Specify an ABI tag(s)")
|
||||
tags_parser.add_argument(
|
||||
"--platform-tag", metavar="TAG", help="Specify a platform tag(s)"
|
||||
)
|
||||
tags_parser.add_argument(
|
||||
"--build", type=parse_build_tag, metavar="BUILD", help="Specify a build tag"
|
||||
)
|
||||
tags_parser.set_defaults(func=tags_f)
|
||||
|
||||
info_parser = s.add_parser("info", help="Show information about a wheel file")
|
||||
info_parser.add_argument("wheelfile", help="Wheel file to show information for")
|
||||
info_parser.add_argument(
|
||||
"--verbose", "-v", action="store_true", help="Show detailed file listing"
|
||||
)
|
||||
info_parser.set_defaults(func=info_f)
|
||||
|
||||
version_parser = s.add_parser("version", help="Print version and exit")
|
||||
version_parser.set_defaults(func=version_f)
|
||||
|
||||
help_parser = s.add_parser("help", help="Show this help")
|
||||
help_parser.set_defaults(func=lambda args: p.print_help())
|
||||
|
||||
return p
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p = parser()
|
||||
args = p.parse_args()
|
||||
if not hasattr(args, "func"):
|
||||
p.print_help()
|
||||
else:
|
||||
try:
|
||||
args.func(args)
|
||||
return 0
|
||||
except WheelError as e:
|
||||
print(e, file=sys.stderr)
|
||||
|
||||
return 1
|
||||
Vendored
BIN
Binary file not shown.
Vendored
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
@@ -0,0 +1,337 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import os.path
|
||||
import re
|
||||
from abc import ABCMeta, abstractmethod
|
||||
from collections import defaultdict
|
||||
from collections.abc import Iterator
|
||||
from email.message import Message
|
||||
from email.parser import Parser
|
||||
from email.policy import EmailPolicy
|
||||
from glob import iglob
|
||||
from pathlib import Path
|
||||
from textwrap import dedent
|
||||
from zipfile import ZipFile
|
||||
|
||||
from packaging.tags import parse_tag
|
||||
|
||||
from .. import __version__
|
||||
from .._metadata import generate_requirements
|
||||
from ..wheelfile import WheelFile
|
||||
|
||||
egg_filename_re = re.compile(
|
||||
r"""
|
||||
(?P<name>.+?)-(?P<ver>.+?)
|
||||
(-(?P<pyver>py\d\.\d+)
|
||||
(-(?P<arch>.+?))?
|
||||
)?.egg$""",
|
||||
re.VERBOSE,
|
||||
)
|
||||
egg_info_re = re.compile(
|
||||
r"""
|
||||
^(?P<name>.+?)-(?P<ver>.+?)
|
||||
(-(?P<pyver>py\d\.\d+)
|
||||
)?.egg-info/""",
|
||||
re.VERBOSE,
|
||||
)
|
||||
wininst_re = re.compile(
|
||||
r"\.(?P<platform>win32|win-amd64)(?:-(?P<pyver>py\d\.\d))?\.exe$"
|
||||
)
|
||||
pyd_re = re.compile(r"\.(?P<abi>[a-z0-9]+)-(?P<platform>win32|win_amd64)\.pyd$")
|
||||
serialization_policy = EmailPolicy(
|
||||
utf8=True,
|
||||
mangle_from_=False,
|
||||
max_line_length=0,
|
||||
)
|
||||
GENERATOR = f"wheel {__version__}"
|
||||
|
||||
|
||||
def convert_requires(requires: str, metadata: Message) -> None:
|
||||
extra: str | None = None
|
||||
requirements: dict[str | None, list[str]] = defaultdict(list)
|
||||
for line in requires.splitlines():
|
||||
line = line.strip()
|
||||
if not line:
|
||||
continue
|
||||
|
||||
if line.startswith("[") and line.endswith("]"):
|
||||
extra = line[1:-1]
|
||||
continue
|
||||
|
||||
requirements[extra].append(line)
|
||||
|
||||
for key, value in generate_requirements(requirements):
|
||||
metadata.add_header(key, value)
|
||||
|
||||
|
||||
def convert_pkg_info(pkginfo: str, metadata: Message) -> None:
|
||||
parsed_message = Parser().parsestr(pkginfo)
|
||||
for key, value in parsed_message.items():
|
||||
key_lower = key.lower()
|
||||
if value == "UNKNOWN":
|
||||
continue
|
||||
|
||||
if key_lower == "description":
|
||||
description_lines = value.splitlines()
|
||||
if description_lines:
|
||||
value = "\n".join(
|
||||
(
|
||||
description_lines[0].lstrip(),
|
||||
dedent("\n".join(description_lines[1:])),
|
||||
"\n",
|
||||
)
|
||||
)
|
||||
else:
|
||||
value = "\n"
|
||||
|
||||
metadata.set_payload(value)
|
||||
elif key_lower == "home-page":
|
||||
metadata.add_header("Project-URL", f"Homepage, {value}")
|
||||
elif key_lower == "download-url":
|
||||
metadata.add_header("Project-URL", f"Download, {value}")
|
||||
else:
|
||||
metadata.add_header(key, value)
|
||||
|
||||
metadata.replace_header("Metadata-Version", "2.4")
|
||||
|
||||
|
||||
def normalize(name: str) -> str:
|
||||
return re.sub(r"[-_.]+", "-", name).lower().replace("-", "_")
|
||||
|
||||
|
||||
class ConvertSource(metaclass=ABCMeta):
|
||||
name: str
|
||||
version: str
|
||||
pyver: str = "py2.py3"
|
||||
abi: str = "none"
|
||||
platform: str = "any"
|
||||
metadata: Message
|
||||
|
||||
@property
|
||||
def dist_info_dir(self) -> str:
|
||||
return f"{self.name}-{self.version}.dist-info"
|
||||
|
||||
@abstractmethod
|
||||
def generate_contents(self) -> Iterator[tuple[str, bytes]]:
|
||||
pass
|
||||
|
||||
|
||||
class EggFileSource(ConvertSource):
|
||||
def __init__(self, path: Path):
|
||||
if not (match := egg_filename_re.match(path.name)):
|
||||
raise ValueError(f"Invalid egg file name: {path.name}")
|
||||
|
||||
# Binary wheels are assumed to be for CPython
|
||||
self.path = path
|
||||
self.name = normalize(match.group("name"))
|
||||
self.version = match.group("ver")
|
||||
if pyver := match.group("pyver"):
|
||||
self.pyver = pyver.replace(".", "")
|
||||
if arch := match.group("arch"):
|
||||
self.abi = self.pyver.replace("py", "cp")
|
||||
self.platform = normalize(arch)
|
||||
|
||||
self.metadata = Message()
|
||||
|
||||
def generate_contents(self) -> Iterator[tuple[str, bytes]]:
|
||||
with ZipFile(self.path, "r") as zip_file:
|
||||
for filename in sorted(zip_file.namelist()):
|
||||
# Skip pure directory entries
|
||||
if filename.endswith("/"):
|
||||
continue
|
||||
|
||||
# Handle files in the egg-info directory specially, selectively moving
|
||||
# them to the dist-info directory while converting as needed
|
||||
if filename.startswith("EGG-INFO/"):
|
||||
if filename == "EGG-INFO/requires.txt":
|
||||
requires = zip_file.read(filename).decode("utf-8")
|
||||
convert_requires(requires, self.metadata)
|
||||
elif filename == "EGG-INFO/PKG-INFO":
|
||||
pkginfo = zip_file.read(filename).decode("utf-8")
|
||||
convert_pkg_info(pkginfo, self.metadata)
|
||||
elif filename == "EGG-INFO/entry_points.txt":
|
||||
yield (
|
||||
f"{self.dist_info_dir}/entry_points.txt",
|
||||
zip_file.read(filename),
|
||||
)
|
||||
|
||||
continue
|
||||
|
||||
# For any other file, just pass it through
|
||||
yield filename, zip_file.read(filename)
|
||||
|
||||
|
||||
class EggDirectorySource(EggFileSource):
|
||||
def generate_contents(self) -> Iterator[tuple[str, bytes]]:
|
||||
for dirpath, _, filenames in os.walk(self.path):
|
||||
for filename in sorted(filenames):
|
||||
path = Path(dirpath, filename)
|
||||
if path.parent.name == "EGG-INFO":
|
||||
if path.name == "requires.txt":
|
||||
requires = path.read_text("utf-8")
|
||||
convert_requires(requires, self.metadata)
|
||||
elif path.name == "PKG-INFO":
|
||||
pkginfo = path.read_text("utf-8")
|
||||
convert_pkg_info(pkginfo, self.metadata)
|
||||
if name := self.metadata.get("Name"):
|
||||
self.name = normalize(name)
|
||||
|
||||
if version := self.metadata.get("Version"):
|
||||
self.version = version
|
||||
elif path.name == "entry_points.txt":
|
||||
yield (
|
||||
f"{self.dist_info_dir}/entry_points.txt",
|
||||
path.read_bytes(),
|
||||
)
|
||||
|
||||
continue
|
||||
|
||||
# For any other file, just pass it through
|
||||
yield str(path.relative_to(self.path)), path.read_bytes()
|
||||
|
||||
|
||||
class WininstFileSource(ConvertSource):
|
||||
"""
|
||||
Handles distributions created with ``bdist_wininst``.
|
||||
|
||||
The egginfo filename has the format::
|
||||
|
||||
name-ver(-pyver)(-arch).egg-info
|
||||
|
||||
The installer filename has the format::
|
||||
|
||||
name-ver.arch(-pyver).exe
|
||||
|
||||
Some things to note:
|
||||
|
||||
1. The installer filename is not definitive. An installer can be renamed
|
||||
and work perfectly well as an installer. So more reliable data should
|
||||
be used whenever possible.
|
||||
2. The egg-info data should be preferred for the name and version, because
|
||||
these come straight from the distutils metadata, and are mandatory.
|
||||
3. The pyver from the egg-info data should be ignored, as it is
|
||||
constructed from the version of Python used to build the installer,
|
||||
which is irrelevant - the installer filename is correct here (even to
|
||||
the point that when it's not there, any version is implied).
|
||||
4. The architecture must be taken from the installer filename, as it is
|
||||
not included in the egg-info data.
|
||||
5. Architecture-neutral installers still have an architecture because the
|
||||
installer format itself (being executable) is architecture-specific. We
|
||||
should therefore ignore the architecture if the content is pure-python.
|
||||
"""
|
||||
|
||||
def __init__(self, path: Path):
|
||||
self.path = path
|
||||
self.metadata = Message()
|
||||
|
||||
# Determine the initial architecture and Python version from the file name
|
||||
# (if possible)
|
||||
if match := wininst_re.search(path.name):
|
||||
self.platform = normalize(match.group("platform"))
|
||||
if pyver := match.group("pyver"):
|
||||
self.pyver = pyver.replace(".", "")
|
||||
|
||||
# Look for an .egg-info directory and any .pyd files for more precise info
|
||||
egg_info_found = pyd_found = False
|
||||
with ZipFile(self.path) as zip_file:
|
||||
for filename in zip_file.namelist():
|
||||
prefix, filename = filename.split("/", 1)
|
||||
if not egg_info_found and (match := egg_info_re.match(filename)):
|
||||
egg_info_found = True
|
||||
self.name = normalize(match.group("name"))
|
||||
self.version = match.group("ver")
|
||||
if pyver := match.group("pyver"):
|
||||
self.pyver = pyver.replace(".", "")
|
||||
elif not pyd_found and (match := pyd_re.search(filename)):
|
||||
pyd_found = True
|
||||
self.abi = match.group("abi")
|
||||
self.platform = match.group("platform")
|
||||
|
||||
if egg_info_found and pyd_found:
|
||||
break
|
||||
|
||||
def generate_contents(self) -> Iterator[tuple[str, bytes]]:
|
||||
dist_info_dir = f"{self.name}-{self.version}.dist-info"
|
||||
data_dir = f"{self.name}-{self.version}.data"
|
||||
with ZipFile(self.path, "r") as zip_file:
|
||||
for filename in sorted(zip_file.namelist()):
|
||||
# Skip pure directory entries
|
||||
if filename.endswith("/"):
|
||||
continue
|
||||
|
||||
# Handle files in the egg-info directory specially, selectively moving
|
||||
# them to the dist-info directory while converting as needed
|
||||
prefix, target_filename = filename.split("/", 1)
|
||||
if egg_info_re.search(target_filename):
|
||||
basename = target_filename.rsplit("/", 1)[-1]
|
||||
if basename == "requires.txt":
|
||||
requires = zip_file.read(filename).decode("utf-8")
|
||||
convert_requires(requires, self.metadata)
|
||||
elif basename == "PKG-INFO":
|
||||
pkginfo = zip_file.read(filename).decode("utf-8")
|
||||
convert_pkg_info(pkginfo, self.metadata)
|
||||
elif basename == "entry_points.txt":
|
||||
yield (
|
||||
f"{dist_info_dir}/entry_points.txt",
|
||||
zip_file.read(filename),
|
||||
)
|
||||
|
||||
continue
|
||||
elif prefix == "SCRIPTS":
|
||||
target_filename = f"{data_dir}/scripts/{target_filename}"
|
||||
|
||||
# For any other file, just pass it through
|
||||
yield target_filename, zip_file.read(filename)
|
||||
|
||||
|
||||
def convert(files: list[str], dest_dir: str, verbose: bool) -> None:
|
||||
for pat in files:
|
||||
for archive in iglob(pat):
|
||||
path = Path(archive)
|
||||
if path.suffix == ".egg":
|
||||
if path.is_dir():
|
||||
source: ConvertSource = EggDirectorySource(path)
|
||||
else:
|
||||
source = EggFileSource(path)
|
||||
else:
|
||||
source = WininstFileSource(path)
|
||||
|
||||
if verbose:
|
||||
print(f"{archive}...", flush=True, end="")
|
||||
|
||||
dest_path = Path(dest_dir) / (
|
||||
f"{source.name}-{source.version}-{source.pyver}-{source.abi}"
|
||||
f"-{source.platform}.whl"
|
||||
)
|
||||
with WheelFile(dest_path, "w") as wheelfile:
|
||||
for name_or_zinfo, contents in source.generate_contents():
|
||||
wheelfile.writestr(name_or_zinfo, contents)
|
||||
|
||||
# Write the METADATA file
|
||||
wheelfile.writestr(
|
||||
f"{source.dist_info_dir}/METADATA",
|
||||
source.metadata.as_string(policy=serialization_policy).encode(
|
||||
"utf-8"
|
||||
),
|
||||
)
|
||||
|
||||
# Write the WHEEL file
|
||||
wheel_message = Message()
|
||||
wheel_message.add_header("Wheel-Version", "1.0")
|
||||
wheel_message.add_header("Generator", GENERATOR)
|
||||
wheel_message.add_header(
|
||||
"Root-Is-Purelib", str(source.platform == "any").lower()
|
||||
)
|
||||
tags = parse_tag(f"{source.pyver}-{source.abi}-{source.platform}")
|
||||
for tag in sorted(tags, key=lambda tag: tag.interpreter):
|
||||
wheel_message.add_header("Tag", str(tag))
|
||||
|
||||
wheelfile.writestr(
|
||||
f"{source.dist_info_dir}/WHEEL",
|
||||
wheel_message.as_string(policy=serialization_policy).encode(
|
||||
"utf-8"
|
||||
),
|
||||
)
|
||||
|
||||
if verbose:
|
||||
print("OK")
|
||||
@@ -0,0 +1,124 @@
|
||||
"""
|
||||
Display information about wheel files.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import email.policy
|
||||
import sys
|
||||
from email.parser import BytesParser
|
||||
from pathlib import Path
|
||||
|
||||
from ..wheelfile import WheelFile
|
||||
|
||||
|
||||
def info(path: str, verbose: bool = False) -> None:
|
||||
"""Display information about a wheel file.
|
||||
|
||||
:param path: The path to the wheel file
|
||||
:param verbose: Show detailed file listing
|
||||
"""
|
||||
wheel_path = Path(path)
|
||||
if not wheel_path.exists():
|
||||
raise FileNotFoundError(f"Wheel file not found: {path}")
|
||||
|
||||
with WheelFile(path) as wf:
|
||||
# Extract basic wheel information from filename
|
||||
parsed = wf.parsed_filename
|
||||
name = parsed.group("name")
|
||||
version = parsed.group("ver")
|
||||
build_tag = parsed.group("build")
|
||||
|
||||
print(f"Name: {name}")
|
||||
print(f"Version: {version}")
|
||||
if build_tag:
|
||||
print(f"Build: {build_tag}")
|
||||
|
||||
# Read WHEEL metadata
|
||||
try:
|
||||
with wf.open(f"{wf.dist_info_path}/WHEEL") as wheel_file:
|
||||
wheel_metadata = BytesParser(policy=email.policy.compat32).parse(
|
||||
wheel_file
|
||||
)
|
||||
|
||||
print(
|
||||
f"Wheel-Version: {wheel_metadata.get('Wheel-Version', 'Unknown')}"
|
||||
)
|
||||
print(
|
||||
f"Root-Is-Purelib: {wheel_metadata.get('Root-Is-Purelib', 'Unknown')}"
|
||||
)
|
||||
|
||||
# Get all tags
|
||||
tags = wheel_metadata.get_all("Tag", [])
|
||||
if tags:
|
||||
print("Tags:")
|
||||
for tag in sorted(tags): # Sort tags for consistent output
|
||||
print(f" {tag}")
|
||||
|
||||
generators = wheel_metadata.get_all("Generator", [])
|
||||
for generator in generators:
|
||||
print(f"Generator: {generator}")
|
||||
except KeyError:
|
||||
print("Warning: WHEEL metadata file not found", file=sys.stderr)
|
||||
|
||||
# Read package METADATA
|
||||
try:
|
||||
with wf.open(f"{wf.dist_info_path}/METADATA") as metadata_file:
|
||||
pkg_metadata = BytesParser(policy=email.policy.compat32).parse(
|
||||
metadata_file
|
||||
)
|
||||
|
||||
summary = pkg_metadata.get("Summary", "")
|
||||
if summary and summary != "UNKNOWN":
|
||||
print(f"Summary: {summary}")
|
||||
|
||||
author = pkg_metadata.get("Author", "")
|
||||
if author and author != "UNKNOWN":
|
||||
print(f"Author: {author}")
|
||||
|
||||
author_email = pkg_metadata.get("Author-email")
|
||||
if author_email and author_email != "UNKNOWN":
|
||||
print(f"Author-email: {author_email}")
|
||||
|
||||
homepage = pkg_metadata.get("Home-page")
|
||||
if homepage and homepage != "UNKNOWN":
|
||||
print(f"Home-page: {homepage}")
|
||||
|
||||
license_info = pkg_metadata.get("License")
|
||||
if license_info and license_info != "UNKNOWN":
|
||||
print(f"License: {license_info}")
|
||||
|
||||
# Show classifiers
|
||||
classifiers = pkg_metadata.get_all("Classifier", [])
|
||||
if classifiers:
|
||||
print("Classifiers:")
|
||||
for classifier in sorted(
|
||||
classifiers[:5]
|
||||
): # Sort and limit to first 5
|
||||
print(f" {classifier}")
|
||||
|
||||
if len(classifiers) > 5:
|
||||
print(f" ... and {len(classifiers) - 5} more")
|
||||
|
||||
# Show dependencies
|
||||
requires_dist = pkg_metadata.get_all("Requires-Dist", [])
|
||||
if requires_dist:
|
||||
print("Requires-Dist:")
|
||||
for req in sorted(requires_dist): # Sort dependencies
|
||||
print(f" {req}")
|
||||
except KeyError:
|
||||
print("Warning: METADATA file not found", file=sys.stderr)
|
||||
|
||||
# File information
|
||||
file_count = len(wf.filelist)
|
||||
total_size = sum(zinfo.file_size for zinfo in wf.filelist)
|
||||
|
||||
print(f"Files: {file_count}")
|
||||
print(f"Size: {total_size:,} bytes")
|
||||
|
||||
# Show file listing if verbose
|
||||
if verbose:
|
||||
print("\nFile listing:")
|
||||
for zinfo in wf.filelist:
|
||||
size_str = f"{zinfo.file_size:,}" if zinfo.file_size > 0 else "0"
|
||||
print(f" {zinfo.filename:60} {size_str:>10} bytes")
|
||||
@@ -0,0 +1,84 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import email.policy
|
||||
import os.path
|
||||
import re
|
||||
from email.generator import BytesGenerator
|
||||
from email.parser import BytesParser
|
||||
|
||||
from ..wheelfile import WheelError, WheelFile
|
||||
|
||||
DIST_INFO_RE = re.compile(r"^(?P<namever>(?P<name>.+?)-(?P<ver>\d.*?))\.dist-info$")
|
||||
|
||||
|
||||
def pack(directory: str, dest_dir: str, build_number: str | None) -> None:
|
||||
"""Repack a previously unpacked wheel directory into a new wheel file.
|
||||
|
||||
The .dist-info/WHEEL file must contain one or more tags so that the target
|
||||
wheel file name can be determined.
|
||||
|
||||
:param directory: The unpacked wheel directory
|
||||
:param dest_dir: Destination directory (defaults to the current directory)
|
||||
"""
|
||||
# Find the .dist-info directory
|
||||
dist_info_dirs = [
|
||||
fn
|
||||
for fn in os.listdir(directory)
|
||||
if os.path.isdir(os.path.join(directory, fn)) and DIST_INFO_RE.match(fn)
|
||||
]
|
||||
if len(dist_info_dirs) > 1:
|
||||
raise WheelError(f"Multiple .dist-info directories found in {directory}")
|
||||
elif not dist_info_dirs:
|
||||
raise WheelError(f"No .dist-info directories found in {directory}")
|
||||
|
||||
# Determine the target wheel filename
|
||||
dist_info_dir = dist_info_dirs[0]
|
||||
name_version = DIST_INFO_RE.match(dist_info_dir).group("namever")
|
||||
|
||||
# Read the tags and the existing build number from .dist-info/WHEEL
|
||||
wheel_file_path = os.path.join(directory, dist_info_dir, "WHEEL")
|
||||
with open(wheel_file_path, "rb") as f:
|
||||
info = BytesParser(policy=email.policy.compat32).parse(f)
|
||||
tags: list[str] = info.get_all("Tag", [])
|
||||
existing_build_number = info.get("Build")
|
||||
|
||||
if not tags:
|
||||
raise WheelError(
|
||||
f"No tags present in {dist_info_dir}/WHEEL; cannot determine target "
|
||||
f"wheel filename"
|
||||
)
|
||||
|
||||
# Set the wheel file name and add/replace/remove the Build tag in .dist-info/WHEEL
|
||||
build_number = build_number if build_number is not None else existing_build_number
|
||||
if build_number is not None:
|
||||
del info["Build"]
|
||||
if build_number:
|
||||
info["Build"] = build_number
|
||||
name_version += "-" + build_number
|
||||
|
||||
if build_number != existing_build_number:
|
||||
with open(wheel_file_path, "wb") as f:
|
||||
BytesGenerator(f, maxheaderlen=0).flatten(info)
|
||||
|
||||
# Reassemble the tags for the wheel file
|
||||
tagline = compute_tagline(tags)
|
||||
|
||||
# Repack the wheel
|
||||
wheel_path = os.path.join(dest_dir, f"{name_version}-{tagline}.whl")
|
||||
with WheelFile(wheel_path, "w") as wf:
|
||||
print(f"Repacking wheel as {wheel_path}...", end="", flush=True)
|
||||
wf.write_files(directory)
|
||||
|
||||
print("OK")
|
||||
|
||||
|
||||
def compute_tagline(tags: list[str]) -> str:
|
||||
"""Compute a tagline from a list of tags.
|
||||
|
||||
:param tags: A list of tags
|
||||
:return: A tagline
|
||||
"""
|
||||
impls = sorted({tag.split("-")[0] for tag in tags})
|
||||
abivers = sorted({tag.split("-")[1] for tag in tags})
|
||||
platforms = sorted({tag.split("-")[2] for tag in tags})
|
||||
return "-".join([".".join(impls), ".".join(abivers), ".".join(platforms)])
|
||||
@@ -0,0 +1,140 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import email.policy
|
||||
import itertools
|
||||
import os
|
||||
from collections.abc import Iterable
|
||||
from email.parser import BytesParser
|
||||
|
||||
from ..wheelfile import WheelFile
|
||||
|
||||
|
||||
def _compute_tags(original_tags: Iterable[str], new_tags: str | None) -> set[str]:
|
||||
"""Add or replace tags. Supports dot-separated tags"""
|
||||
if new_tags is None:
|
||||
return set(original_tags)
|
||||
|
||||
if new_tags.startswith("+"):
|
||||
return {*original_tags, *new_tags[1:].split(".")}
|
||||
|
||||
if new_tags.startswith("-"):
|
||||
return set(original_tags) - set(new_tags[1:].split("."))
|
||||
|
||||
return set(new_tags.split("."))
|
||||
|
||||
|
||||
def tags(
|
||||
wheel: str,
|
||||
python_tags: str | None = None,
|
||||
abi_tags: str | None = None,
|
||||
platform_tags: str | None = None,
|
||||
build_tag: str | None = None,
|
||||
remove: bool = False,
|
||||
) -> str:
|
||||
"""Change the tags on a wheel file.
|
||||
|
||||
The tags are left unchanged if they are not specified. To specify "none",
|
||||
use ["none"]. To append to the previous tags, a tag should start with a
|
||||
"+". If a tag starts with "-", it will be removed from existing tags.
|
||||
Processing is done left to right.
|
||||
|
||||
:param wheel: The paths to the wheels
|
||||
:param python_tags: The Python tags to set
|
||||
:param abi_tags: The ABI tags to set
|
||||
:param platform_tags: The platform tags to set
|
||||
:param build_tag: The build tag to set
|
||||
:param remove: Remove the original wheel
|
||||
"""
|
||||
with WheelFile(wheel, "r") as f:
|
||||
assert f.filename, f"{f.filename} must be available"
|
||||
|
||||
wheel_info = f.read(f.dist_info_path + "/WHEEL")
|
||||
info = BytesParser(policy=email.policy.compat32).parsebytes(wheel_info)
|
||||
|
||||
original_wheel_name = os.path.basename(f.filename)
|
||||
namever = f.parsed_filename.group("namever")
|
||||
build = f.parsed_filename.group("build")
|
||||
original_python_tags = f.parsed_filename.group("pyver").split(".")
|
||||
original_abi_tags = f.parsed_filename.group("abi").split(".")
|
||||
original_plat_tags = f.parsed_filename.group("plat").split(".")
|
||||
|
||||
tags: list[str] = info.get_all("Tag", [])
|
||||
existing_build_tag = info.get("Build")
|
||||
|
||||
impls = {tag.split("-")[0] for tag in tags}
|
||||
abivers = {tag.split("-")[1] for tag in tags}
|
||||
platforms = {tag.split("-")[2] for tag in tags}
|
||||
|
||||
if impls != set(original_python_tags):
|
||||
msg = f"Wheel internal tags {impls!r} != filename tags {original_python_tags!r}"
|
||||
raise AssertionError(msg)
|
||||
|
||||
if abivers != set(original_abi_tags):
|
||||
msg = f"Wheel internal tags {abivers!r} != filename tags {original_abi_tags!r}"
|
||||
raise AssertionError(msg)
|
||||
|
||||
if platforms != set(original_plat_tags):
|
||||
msg = (
|
||||
f"Wheel internal tags {platforms!r} != filename tags {original_plat_tags!r}"
|
||||
)
|
||||
raise AssertionError(msg)
|
||||
|
||||
if existing_build_tag != build:
|
||||
msg = (
|
||||
f"Incorrect filename '{build}' "
|
||||
f"& *.dist-info/WHEEL '{existing_build_tag}' build numbers"
|
||||
)
|
||||
raise AssertionError(msg)
|
||||
|
||||
# Start changing as needed
|
||||
if build_tag is not None:
|
||||
build = build_tag
|
||||
|
||||
final_python_tags = sorted(_compute_tags(original_python_tags, python_tags))
|
||||
final_abi_tags = sorted(_compute_tags(original_abi_tags, abi_tags))
|
||||
final_plat_tags = sorted(_compute_tags(original_plat_tags, platform_tags))
|
||||
|
||||
final_tags = [
|
||||
namever,
|
||||
".".join(final_python_tags),
|
||||
".".join(final_abi_tags),
|
||||
".".join(final_plat_tags),
|
||||
]
|
||||
if build:
|
||||
final_tags.insert(1, build)
|
||||
|
||||
final_wheel_name = "-".join(final_tags) + ".whl"
|
||||
|
||||
if original_wheel_name != final_wheel_name:
|
||||
del info["Tag"], info["Build"]
|
||||
for a, b, c in itertools.product(
|
||||
final_python_tags, final_abi_tags, final_plat_tags
|
||||
):
|
||||
info["Tag"] = f"{a}-{b}-{c}"
|
||||
if build:
|
||||
info["Build"] = build
|
||||
|
||||
original_wheel_path = os.path.join(
|
||||
os.path.dirname(f.filename), original_wheel_name
|
||||
)
|
||||
final_wheel_path = os.path.join(os.path.dirname(f.filename), final_wheel_name)
|
||||
|
||||
with (
|
||||
WheelFile(original_wheel_path, "r") as fin,
|
||||
WheelFile(final_wheel_path, "w") as fout,
|
||||
):
|
||||
fout.comment = fin.comment # preserve the comment
|
||||
for item in fin.infolist():
|
||||
if item.is_dir():
|
||||
continue
|
||||
if item.filename == f.dist_info_path + "/RECORD":
|
||||
continue
|
||||
if item.filename == f.dist_info_path + "/WHEEL":
|
||||
fout.writestr(item, info.as_bytes())
|
||||
else:
|
||||
fout.writestr(item, fin.read(item))
|
||||
|
||||
if remove:
|
||||
os.remove(original_wheel_path)
|
||||
|
||||
return final_wheel_name
|
||||
@@ -0,0 +1,30 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from ..wheelfile import WheelFile
|
||||
|
||||
|
||||
def unpack(path: str, dest: str = ".") -> None:
|
||||
"""Unpack a wheel.
|
||||
|
||||
Wheel content will be unpacked to {dest}/{name}-{ver}, where {name}
|
||||
is the package name and {ver} its version.
|
||||
|
||||
:param path: The path to the wheel.
|
||||
:param dest: Destination directory (default to current directory).
|
||||
"""
|
||||
with WheelFile(path) as wf:
|
||||
namever = wf.parsed_filename.group("namever")
|
||||
destination = Path(dest) / namever
|
||||
print(f"Unpacking to: {destination}...", end="", flush=True)
|
||||
for zinfo in wf.filelist:
|
||||
target_path = Path(wf.extract(zinfo, destination))
|
||||
|
||||
# Set permissions to the same values as they were set in the archive
|
||||
# We have to do this manually due to
|
||||
# https://github.com/python/cpython/issues/59999
|
||||
permissions = zinfo.external_attr >> 16 & 0o777
|
||||
target_path.chmod(permissions)
|
||||
|
||||
print("OK")
|
||||
Reference in New Issue
Block a user