from __future__ import annotations
|
|
import functools
|
import importlib
|
import io
|
from email import message_from_string
|
from email.generator import Generator
|
from email.message import EmailMessage, Message
|
from email.parser import Parser
|
from email.policy import EmailPolicy
|
from inspect import cleandoc
|
from pathlib import Path
|
from unittest.mock import Mock
|
|
import jaraco.path
|
import pytest
|
from packaging.metadata import Metadata
|
from packaging.requirements import Requirement
|
|
from setuptools import _reqs, sic
|
from setuptools._core_metadata import rfc822_escape, rfc822_unescape
|
from setuptools.command.egg_info import egg_info, write_requirements
|
from setuptools.config import expand, setupcfg
|
from setuptools.dist import Distribution
|
|
from .config.downloads import retrieve_file, urls_from_file
|
|
EXAMPLE_BASE_INFO = dict(
|
name="package",
|
version="0.0.1",
|
author="Foo Bar",
|
author_email="foo@bar.net",
|
long_description="Long\ndescription",
|
description="Short description",
|
keywords=["one", "two"],
|
)
|
|
|
@pytest.mark.parametrize(
|
("content", "result"),
|
(
|
pytest.param(
|
"Just a single line",
|
None,
|
id="single_line",
|
),
|
pytest.param(
|
"Multiline\nText\nwithout\nextra indents\n",
|
None,
|
id="multiline",
|
),
|
pytest.param(
|
"Multiline\n With\n\nadditional\n indentation",
|
None,
|
id="multiline_with_indentation",
|
),
|
pytest.param(
|
" Leading whitespace",
|
"Leading whitespace",
|
id="remove_leading_whitespace",
|
),
|
pytest.param(
|
" Leading whitespace\nIn\n Multiline comment",
|
"Leading whitespace\nIn\n Multiline comment",
|
id="remove_leading_whitespace_multiline",
|
),
|
),
|
)
|
def test_rfc822_unescape(content, result):
|
assert (result or content) == rfc822_unescape(rfc822_escape(content))
|
|
|
def __read_test_cases():
|
base = EXAMPLE_BASE_INFO
|
|
params = functools.partial(dict, base)
|
|
return [
|
('Metadata version 1.0', params()),
|
(
|
'Metadata Version 1.0: Short long description',
|
params(
|
long_description='Short long description',
|
),
|
),
|
(
|
'Metadata version 1.1: Classifiers',
|
params(
|
classifiers=[
|
'Programming Language :: Python :: 3',
|
'Programming Language :: Python :: 3.7',
|
'License :: OSI Approved :: MIT License',
|
],
|
),
|
),
|
(
|
'Metadata version 1.1: Download URL',
|
params(
|
download_url='https://example.com',
|
),
|
),
|
(
|
'Metadata Version 1.2: Requires-Python',
|
params(
|
python_requires='>=3.7',
|
),
|
),
|
pytest.param(
|
'Metadata Version 1.2: Project-Url',
|
params(project_urls=dict(Foo='https://example.bar')),
|
marks=pytest.mark.xfail(
|
reason="Issue #1578: project_urls not read",
|
),
|
),
|
(
|
'Metadata Version 2.1: Long Description Content Type',
|
params(
|
long_description_content_type='text/x-rst; charset=UTF-8',
|
),
|
),
|
(
|
'License',
|
params(
|
license='MIT',
|
),
|
),
|
(
|
'License multiline',
|
params(
|
license='This is a long license \nover multiple lines',
|
),
|
),
|
pytest.param(
|
'Metadata Version 2.1: Provides Extra',
|
params(provides_extras=['foo', 'bar']),
|
marks=pytest.mark.xfail(reason="provides_extras not read"),
|
),
|
(
|
'Missing author',
|
dict(
|
name='foo',
|
version='1.0.0',
|
author_email='snorri@sturluson.name',
|
),
|
),
|
(
|
'Missing author e-mail',
|
dict(
|
name='foo',
|
version='1.0.0',
|
author='Snorri Sturluson',
|
),
|
),
|
(
|
'Missing author and e-mail',
|
dict(
|
name='foo',
|
version='1.0.0',
|
),
|
),
|
(
|
'Bypass normalized version',
|
dict(
|
name='foo',
|
version=sic('1.0.0a'),
|
),
|
),
|
]
|
|
|
@pytest.mark.parametrize(("name", "attrs"), __read_test_cases())
|
def test_read_metadata(name, attrs):
|
dist = Distribution(attrs)
|
metadata_out = dist.metadata
|
dist_class = metadata_out.__class__
|
|
# Write to PKG_INFO and then load into a new metadata object
|
PKG_INFO = io.StringIO()
|
|
metadata_out.write_pkg_file(PKG_INFO)
|
PKG_INFO.seek(0)
|
pkg_info = PKG_INFO.read()
|
assert _valid_metadata(pkg_info)
|
|
PKG_INFO.seek(0)
|
metadata_in = dist_class()
|
metadata_in.read_pkg_file(PKG_INFO)
|
|
tested_attrs = [
|
('name', dist_class.get_name),
|
('version', dist_class.get_version),
|
('author', dist_class.get_contact),
|
('author_email', dist_class.get_contact_email),
|
('metadata_version', dist_class.get_metadata_version),
|
('provides', dist_class.get_provides),
|
('description', dist_class.get_description),
|
('long_description', dist_class.get_long_description),
|
('download_url', dist_class.get_download_url),
|
('keywords', dist_class.get_keywords),
|
('platforms', dist_class.get_platforms),
|
('obsoletes', dist_class.get_obsoletes),
|
('requires', dist_class.get_requires),
|
('classifiers', dist_class.get_classifiers),
|
('project_urls', lambda s: getattr(s, 'project_urls', {})),
|
('provides_extras', lambda s: getattr(s, 'provides_extras', {})),
|
]
|
|
for attr, getter in tested_attrs:
|
assert getter(metadata_in) == getter(metadata_out)
|
|
|
def __maintainer_test_cases():
|
attrs = {"name": "package", "version": "1.0", "description": "xxx"}
|
|
def merge_dicts(d1, d2):
|
d1 = d1.copy()
|
d1.update(d2)
|
|
return d1
|
|
return [
|
('No author, no maintainer', attrs.copy()),
|
(
|
'Author (no e-mail), no maintainer',
|
merge_dicts(attrs, {'author': 'Author Name'}),
|
),
|
(
|
'Author (e-mail), no maintainer',
|
merge_dicts(
|
attrs, {'author': 'Author Name', 'author_email': 'author@name.com'}
|
),
|
),
|
(
|
'No author, maintainer (no e-mail)',
|
merge_dicts(attrs, {'maintainer': 'Maintainer Name'}),
|
),
|
(
|
'No author, maintainer (e-mail)',
|
merge_dicts(
|
attrs,
|
{
|
'maintainer': 'Maintainer Name',
|
'maintainer_email': 'maintainer@name.com',
|
},
|
),
|
),
|
(
|
'Author (no e-mail), Maintainer (no-email)',
|
merge_dicts(
|
attrs, {'author': 'Author Name', 'maintainer': 'Maintainer Name'}
|
),
|
),
|
(
|
'Author (e-mail), Maintainer (e-mail)',
|
merge_dicts(
|
attrs,
|
{
|
'author': 'Author Name',
|
'author_email': 'author@name.com',
|
'maintainer': 'Maintainer Name',
|
'maintainer_email': 'maintainer@name.com',
|
},
|
),
|
),
|
(
|
'No author (e-mail), no maintainer (e-mail)',
|
merge_dicts(
|
attrs,
|
{
|
'author_email': 'author@name.com',
|
'maintainer_email': 'maintainer@name.com',
|
},
|
),
|
),
|
('Author unicode', merge_dicts(attrs, {'author': '鉄沢寛'})),
|
('Maintainer unicode', merge_dicts(attrs, {'maintainer': 'Jan Łukasiewicz'})),
|
]
|
|
|
@pytest.mark.parametrize(("name", "attrs"), __maintainer_test_cases())
|
def test_maintainer_author(name, attrs, tmpdir):
|
tested_keys = {
|
'author': 'Author',
|
'author_email': 'Author-email',
|
'maintainer': 'Maintainer',
|
'maintainer_email': 'Maintainer-email',
|
}
|
|
# Generate a PKG-INFO file
|
dist = Distribution(attrs)
|
fn = tmpdir.mkdir('pkg_info')
|
fn_s = str(fn)
|
|
dist.metadata.write_pkg_info(fn_s)
|
|
with open(str(fn.join('PKG-INFO')), 'r', encoding='utf-8') as f:
|
pkg_info = f.read()
|
|
assert _valid_metadata(pkg_info)
|
|
# Drop blank lines and strip lines from default description
|
raw_pkg_lines = pkg_info.splitlines()
|
pkg_lines = list(filter(None, raw_pkg_lines[:-2]))
|
|
pkg_lines_set = set(pkg_lines)
|
|
# Duplicate lines should not be generated
|
assert len(pkg_lines) == len(pkg_lines_set)
|
|
for fkey, dkey in tested_keys.items():
|
val = attrs.get(dkey, None)
|
if val is None:
|
for line in pkg_lines:
|
assert not line.startswith(fkey + ':')
|
else:
|
line = f'{fkey}: {val}'
|
assert line in pkg_lines_set
|
|
|
class TestParityWithMetadataFromPyPaWheel:
|
def base_example(self):
|
attrs = dict(
|
**EXAMPLE_BASE_INFO,
|
# Example with complex requirement definition
|
python_requires=">=3.8",
|
install_requires="""
|
packaging==23.2
|
more-itertools==8.8.0; extra == "other"
|
jaraco.text==3.7.0
|
importlib-resources==5.10.2; python_version<"3.8"
|
importlib-metadata==6.0.0 ; python_version<"3.8"
|
colorama>=0.4.4; sys_platform == "win32"
|
""",
|
extras_require={
|
"testing": """
|
pytest >= 6
|
pytest-checkdocs >= 2.4
|
tomli ; \\
|
# Using stdlib when possible
|
python_version < "3.11"
|
ini2toml[lite]>=0.9
|
""",
|
"other": [],
|
},
|
)
|
# Generate a PKG-INFO file using setuptools
|
return Distribution(attrs)
|
|
def test_requires_dist(self, tmp_path):
|
dist = self.base_example()
|
pkg_info = _get_pkginfo(dist)
|
assert _valid_metadata(pkg_info)
|
|
# Ensure Requires-Dist is present
|
expected = [
|
'Metadata-Version:',
|
'Requires-Python: >=3.8',
|
'Provides-Extra: other',
|
'Provides-Extra: testing',
|
'Requires-Dist: tomli; python_version < "3.11" and extra == "testing"',
|
'Requires-Dist: more-itertools==8.8.0; extra == "other"',
|
'Requires-Dist: ini2toml[lite]>=0.9; extra == "testing"',
|
]
|
for line in expected:
|
assert line in pkg_info
|
|
HERE = Path(__file__).parent
|
EXAMPLES_FILE = HERE / "config/setupcfg_examples.txt"
|
|
@pytest.fixture(params=[None, *urls_from_file(EXAMPLES_FILE)])
|
def dist(self, request, monkeypatch, tmp_path):
|
"""Example of distribution with arbitrary configuration"""
|
monkeypatch.chdir(tmp_path)
|
monkeypatch.setattr(expand, "read_attr", Mock(return_value="0.42"))
|
monkeypatch.setattr(expand, "read_files", Mock(return_value="hello world"))
|
monkeypatch.setattr(
|
Distribution, "_finalize_license_files", Mock(return_value=None)
|
)
|
if request.param is None:
|
yield self.base_example()
|
else:
|
# Real-world usage
|
config = retrieve_file(request.param)
|
yield setupcfg.apply_configuration(Distribution({}), config)
|
|
@pytest.mark.uses_network
|
def test_equivalent_output(self, tmp_path, dist):
|
"""Ensure output from setuptools is equivalent to the one from `pypa/wheel`"""
|
# Generate a METADATA file using pypa/wheel for comparison
|
wheel_metadata = importlib.import_module("wheel.metadata")
|
pkginfo_to_metadata = getattr(wheel_metadata, "pkginfo_to_metadata", None)
|
|
if pkginfo_to_metadata is None: # pragma: nocover
|
pytest.xfail(
|
"wheel.metadata.pkginfo_to_metadata is undefined, "
|
"(this is likely to be caused by API changes in pypa/wheel"
|
)
|
|
# Generate an simplified "egg-info" dir for pypa/wheel to convert
|
pkg_info = _get_pkginfo(dist)
|
egg_info_dir = tmp_path / "pkg.egg-info"
|
egg_info_dir.mkdir(parents=True)
|
(egg_info_dir / "PKG-INFO").write_text(pkg_info, encoding="utf-8")
|
write_requirements(egg_info(dist), egg_info_dir, egg_info_dir / "requires.txt")
|
|
# Get pypa/wheel generated METADATA but normalize requirements formatting
|
metadata_msg = pkginfo_to_metadata(egg_info_dir, egg_info_dir / "PKG-INFO")
|
metadata_str = _normalize_metadata(metadata_msg)
|
pkg_info_msg = message_from_string(pkg_info)
|
pkg_info_str = _normalize_metadata(pkg_info_msg)
|
|
# Compare setuptools PKG-INFO x pypa/wheel METADATA
|
assert metadata_str == pkg_info_str
|
|
# Make sure it parses/serializes well in pypa/wheel
|
_assert_roundtrip_message(pkg_info)
|
|
|
class TestPEP643:
|
STATIC_CONFIG = {
|
"setup.cfg": cleandoc(
|
"""
|
[metadata]
|
name = package
|
version = 0.0.1
|
author = Foo Bar
|
author_email = foo@bar.net
|
long_description = Long
|
description
|
description = Short description
|
keywords = one, two
|
platforms = abcd
|
[options]
|
install_requires = requests
|
"""
|
),
|
"pyproject.toml": cleandoc(
|
"""
|
[project]
|
name = "package"
|
version = "0.0.1"
|
authors = [
|
{name = "Foo Bar", email = "foo@bar.net"}
|
]
|
description = "Short description"
|
readme = {text = "Long\\ndescription", content-type = "text/plain"}
|
keywords = ["one", "two"]
|
dependencies = ["requests"]
|
license = "AGPL-3.0-or-later"
|
[tool.setuptools]
|
provides = ["abcd"]
|
obsoletes = ["abcd"]
|
"""
|
),
|
}
|
|
@pytest.mark.parametrize("file", STATIC_CONFIG.keys())
|
def test_static_config_has_no_dynamic(self, file, tmpdir_cwd):
|
Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8")
|
metadata = _get_metadata()
|
assert metadata.get_all("Dynamic") is None
|
assert metadata.get_all("dynamic") is None
|
|
@pytest.mark.parametrize("file", STATIC_CONFIG.keys())
|
@pytest.mark.parametrize(
|
"fields",
|
[
|
# Single dynamic field
|
{"requires-python": ("python_requires", ">=3.12")},
|
{"author-email": ("author_email", "snoopy@peanuts.com")},
|
{"keywords": ("keywords", ["hello", "world"])},
|
{"platform": ("platforms", ["abcd"])},
|
# Multiple dynamic fields
|
{
|
"summary": ("description", "hello world"),
|
"description": ("long_description", "bla bla bla bla"),
|
"requires-dist": ("install_requires", ["hello-world"]),
|
},
|
],
|
)
|
def test_modified_fields_marked_as_dynamic(self, file, fields, tmpdir_cwd):
|
# We start with a static config
|
Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8")
|
dist = _makedist()
|
|
# ... but then we simulate the effects of a plugin modifying the distribution
|
for attr, value in fields.values():
|
# `dist` and `dist.metadata` are complicated...
|
# Some attributes work when set on `dist`, others on `dist.metadata`...
|
# Here we set in both just in case (this also avoids calling `_finalize_*`)
|
setattr(dist, attr, value)
|
setattr(dist.metadata, attr, value)
|
|
# Then we should be able to list the modified fields as Dynamic
|
metadata = _get_metadata(dist)
|
assert set(metadata.get_all("Dynamic")) == set(fields)
|
|
@pytest.mark.parametrize(
|
"extra_toml",
|
[
|
"# Let setuptools autofill license-files",
|
"license-files = ['LICENSE*', 'AUTHORS*', 'NOTICE']",
|
],
|
)
|
def test_license_files_dynamic(self, extra_toml, tmpdir_cwd):
|
# For simplicity (and for the time being) setuptools is not making
|
# any special handling to guarantee `License-File` is considered static.
|
# Instead we rely in the fact that, although suboptimal, it is OK to have
|
# it as dynamics, as per:
|
# https://github.com/pypa/setuptools/issues/4629#issuecomment-2331233677
|
files = {
|
"pyproject.toml": self.STATIC_CONFIG["pyproject.toml"].replace(
|
'license = "AGPL-3.0-or-later"',
|
f"dynamic = ['license']\n{extra_toml}",
|
),
|
"LICENSE.md": "--- mock license ---",
|
"NOTICE": "--- mock notice ---",
|
"AUTHORS.txt": "--- me ---",
|
}
|
# Sanity checks:
|
assert extra_toml in files["pyproject.toml"]
|
assert 'license = "AGPL-3.0-or-later"' not in extra_toml
|
|
jaraco.path.build(files)
|
dist = _makedist(license_expression="AGPL-3.0-or-later")
|
metadata = _get_metadata(dist)
|
assert set(metadata.get_all("Dynamic")) == {
|
'license-file',
|
'license-expression',
|
}
|
assert metadata.get("License-Expression") == "AGPL-3.0-or-later"
|
assert set(metadata.get_all("License-File")) == {
|
"NOTICE",
|
"AUTHORS.txt",
|
"LICENSE.md",
|
}
|
|
|
def _makedist(**attrs):
|
dist = Distribution(attrs)
|
dist.parse_config_files()
|
return dist
|
|
|
def _assert_roundtrip_message(metadata: str) -> None:
|
"""Emulate the way wheel.bdist_wheel parses and regenerates the message,
|
then ensures the metadata generated by setuptools is compatible.
|
"""
|
with io.StringIO(metadata) as buffer:
|
msg = Parser(EmailMessage).parse(buffer)
|
|
serialization_policy = EmailPolicy(
|
utf8=True,
|
mangle_from_=False,
|
max_line_length=0,
|
)
|
with io.BytesIO() as buffer:
|
out = io.TextIOWrapper(buffer, encoding="utf-8")
|
Generator(out, policy=serialization_policy).flatten(msg)
|
out.flush()
|
regenerated = buffer.getvalue()
|
|
raw_metadata = bytes(metadata, "utf-8")
|
# Normalise newlines to avoid test errors on Windows:
|
raw_metadata = b"\n".join(raw_metadata.splitlines())
|
regenerated = b"\n".join(regenerated.splitlines())
|
assert regenerated == raw_metadata
|
|
|
def _normalize_metadata(msg: Message) -> str:
|
"""Allow equivalent metadata to be compared directly"""
|
# The main challenge regards the requirements and extras.
|
# Both setuptools and wheel already apply some level of normalization
|
# but they differ regarding which character is chosen, according to the
|
# following spec it should be "-":
|
# https://packaging.python.org/en/latest/specifications/name-normalization/
|
|
# Related issues:
|
# https://github.com/pypa/packaging/issues/845
|
# https://github.com/pypa/packaging/issues/644#issuecomment-2429813968
|
|
extras = {x.replace("_", "-"): x for x in msg.get_all("Provides-Extra", [])}
|
reqs = [
|
_normalize_req(req, extras)
|
for req in _reqs.parse(msg.get_all("Requires-Dist", []))
|
]
|
del msg["Requires-Dist"]
|
del msg["Provides-Extra"]
|
|
# Ensure consistent ord
|
for req in sorted(reqs):
|
msg["Requires-Dist"] = req
|
for extra in sorted(extras):
|
msg["Provides-Extra"] = extra
|
|
# TODO: Handle lack of PEP 643 implementation in pypa/wheel?
|
del msg["Metadata-Version"]
|
|
return msg.as_string()
|
|
|
def _normalize_req(req: Requirement, extras: dict[str, str]) -> str:
|
"""Allow equivalent requirement objects to be compared directly"""
|
as_str = str(req).replace(req.name, req.name.replace("_", "-"))
|
for norm, orig in extras.items():
|
as_str = as_str.replace(orig, norm)
|
return as_str
|
|
|
def _get_pkginfo(dist: Distribution):
|
with io.StringIO() as fp:
|
dist.metadata.write_pkg_file(fp)
|
return fp.getvalue()
|
|
|
def _get_metadata(dist: Distribution | None = None):
|
return message_from_string(_get_pkginfo(dist or _makedist()))
|
|
|
def _valid_metadata(text: str) -> bool:
|
metadata = Metadata.from_email(text, validate=True) # can raise exceptions
|
return metadata is not None
|
