First draft implementation of '_static' in preparation for PEP 643

Author: abravalheri

setuptools/_core_metadata.py

@@ -18,7 +18,7 @@
 from packaging.utils import canonicalize_name, canonicalize_version
 from packaging.version import Version
 
-from . import _normalization, _reqs
+from . import _normalization, _reqs, _static
 from .warnings import SetuptoolsDeprecationWarning
 
 from distutils.util import rfc822_escape
@@ -27,7 +27,7 @@
 def get_metadata_version(self):
     mv = getattr(self, 'metadata_version', None)
     if mv is None:
-        mv = Version('2.1')
+        mv = Version('2.2')
         self.metadata_version = mv
     return mv
 
@@ -207,6 +207,10 @@ def write_field(key, value):
     self._write_list(file, 'License-File', self.license_files or [])
     _write_requirements(self, file)
 
+    for field, attr in _POSSIBLE_DYNAMIC_FIELDS.items():
+        if hasattr(self, attr) and not isinstance(getattr(self, attr), _static.Static):
+            write_field('Dynamic', field)
+
     long_description = self.get_long_description()
     if long_description:
         file.write(f"\n{long_description}")
@@ -284,3 +288,32 @@ def _distribution_fullname(name: str, version: str) -> str:
         canonicalize_name(name).replace('-', '_'),
         canonicalize_version(version, strip_trailing_zero=False),
     )
+
+
+_POSSIBLE_DYNAMIC_FIELDS = {
+    "author": "author",
+    "author-email": "author_email",
+    "classifier": "classifiers",
+    "description": "long_description",
+    "description-content-type": "long_description_content_type",
+    "download-url": "download_url",
+    "home-page": "url",
+    "keywords": "keywords",
+    "license": "license",
+    # "license-file": "license_files", # PEP 639 allows backfilling without dynamic ??
+    "maintainer": "maintainer",
+    "maintainer-email": "maintainer_email",
+    "obsoletes": "obsoletes",
+    # "obsoletes-dist": "obsoletes_dist",  # NOT USED
+    "platform": "platforms",
+    "project-url": "project_urls",
+    "provides": "provides",
+    # "provides-dist": "provides_dist",  # NOT USED
+    "provides-extra": "extras_require",
+    "requires": "requires",
+    "requires-dist": "install_requires",
+    # "requires-external": "requires_external",  # NOT USED
+    "requires-python": "python_requires",
+    "summary": "description",
+    # "supported-platform": "supported_platforms",  # NOT USED
+}

setuptools/_static.py

@@ -0,0 +1,83 @@
+from collections import abc
+from functools import singledispatch
+
+import packaging.specifiers
+
+
+class Static:
+    """
+    Wrapper for butil-in object types that are allow setuptools to identify
+    static core metadata (in opposition to ``Dynamic``, as defined :pep:`643`).
+
+    The trick is to mark values with :class:`Static` when they come from
+    ``pyproject.toml`` or ``setup.cfg``, so if any plugin overwrite the value
+    with a built-in, setuptools will be able to recognise the change.
+
+    We inherit from built-in classes, so that we don't need to change the existing
+    code base to deal with the new types.
+    We also prefer "immutable-ish" objects to avoid changes after the initial parsing.
+    """
+
+
+class Str(str, Static):
+    pass
+
+
+class Tuple(tuple, Static):
+    pass
+
+
+class Mapping(dict, Static):
+    pass
+
+
+def _do_not_modify(*_, **__):
+    raise NotImplementedError("Direct modification disallowed (statically defined)")
+
+
+# Make `Mapping` immutable-ish (we cannot inherit from types.MappingProxyType):
+for _method in (
+    '__delitem__',
+    '__ior__',
+    '__setitem__',
+    'clear',
+    'pop',
+    'popitem',
+    'setdefault',
+    'update',
+):
+    setattr(Mapping, _method, _do_not_modify)
+
+
+class SpeficierSet(packaging.specifiers.SpecifierSet, Static):
+    """Not exactly a builtin type but useful for ``requires-python``"""
+
+
+@singledispatch
+def convert(value):
+    return value
+
+
+@convert.register
+def _(value: str) -> Str:
+    return Str(value)
+
+
+@convert.register
+def _(value: str) -> Str:
+    return Str(value)
+
+
+@convert.register
+def _(value: tuple) -> Tuple:
+    return Tuple(value)
+
+
+@convert.register
+def _(value: list) -> Tuple:
+    return Tuple(value)
+
+
+@convert.register
+def _(value: abc.Mapping) -> Mapping:
+    return Mapping(value)

setuptools/config/expand.py

@@ -34,6 +34,7 @@
 from types import ModuleType, TracebackType
 from typing import TYPE_CHECKING, Any, Callable, TypeVar
 
+from .. import _static
 from .._path import StrPath, same_path as _same_path
 from ..discovery import find_package_path
 from ..warnings import SetuptoolsWarning
@@ -181,7 +182,8 @@ def read_attr(
     spec = _find_spec(module_name, path)
 
     try:
-        return getattr(StaticModule(module_name, spec), attr_name)
+        value = getattr(StaticModule(module_name, spec), attr_name)
+        return _static.convert(value)
     except Exception:
         # fallback to evaluate module
         module = _load_spec(spec, module_name)

setuptools/config/setupcfg.py

@@ -21,9 +21,9 @@
 
 from packaging.markers import default_environment as marker_env
 from packaging.requirements import InvalidRequirement, Requirement
-from packaging.specifiers import SpecifierSet
 from packaging.version import InvalidVersion, Version
 
+from .. import _static
 from .._path import StrPath
 from ..errors import FileError, OptionError
 from ..warnings import SetuptoolsDeprecationWarning
@@ -309,7 +309,7 @@ def _parse_list(cls, value, separator=','):
 
         :param value:
         :param separator: List items separator character.
-        :rtype: list
+        :rtype: tuple
         """
         if isinstance(value, list):  # _get_parser_compound case
             return value
@@ -367,7 +367,7 @@ def parser(value):
                     f'Only strings are accepted for the {key} field, '
                     'files are not accepted'
                 )
-            return value
+            return _static.Str(value)
 
         return parser
 
@@ -387,15 +387,15 @@ def _parse_file(self, value, root_dir: StrPath | None):
         include_directive = 'file:'
 
         if not isinstance(value, str):
-            return value
+            return _static.convert(value)
 
         if not value.startswith(include_directive):
-            return value
+            return _static.Str(value)
 
         spec = value[len(include_directive) :]
         filepaths = [path.strip() for path in spec.split(',')]
         self._referenced_files.update(filepaths)
-        return expand.read_files(filepaths, root_dir)
+        return _static.Str(expand.read_files(filepaths, root_dir))  # Too optimistic?
 
     def _parse_attr(self, value, package_dir, root_dir: StrPath):
         """Represents value as a module attribute.
@@ -409,7 +409,7 @@ def _parse_attr(self, value, package_dir, root_dir: StrPath):
         """
         attr_directive = 'attr:'
         if not value.startswith(attr_directive):
-            return value
+            return _static.Str(value)
 
         attr_desc = value.replace(attr_directive, '')
 
@@ -473,7 +473,7 @@ def parse_section(self, section_options) -> None:
         for name, (_, value) in section_options.items():
             with contextlib.suppress(KeyError):
                 # Keep silent for a new option may appear anytime.
-                self[name] = value
+                self[name] = _static.convert(value)
 
     def parse(self) -> None:
         """Parses configuration file items from one
@@ -548,23 +548,23 @@ def __init__(
     @property
     def parsers(self):
         """Metadata item name to parser function mapping."""
-        parse_list = self._parse_list
+        parse_tuple_static = self._get_parser_compound(self._parse_list, _static.Tuple)
+        parse_dict_static = self._get_parser_compound(self._parse_dict, _static.Mapping)
         parse_file = partial(self._parse_file, root_dir=self.root_dir)
-        parse_dict = self._parse_dict
         exclude_files_parser = self._exclude_files_parser
 
         return {
-            'platforms': parse_list,
-            'keywords': parse_list,
-            'provides': parse_list,
-            'obsoletes': parse_list,
-            'classifiers': self._get_parser_compound(parse_file, parse_list),
+            'platforms': parse_tuple_static,
+            'keywords': parse_tuple_static,
+            'provides': parse_tuple_static,
+            'obsoletes': parse_tuple_static,
+            'classifiers': self._get_parser_compound(parse_file, parse_tuple_static),
             'license': exclude_files_parser('license'),
-            'license_files': parse_list,
+            'license_files': parse_tuple_static,
             'description': parse_file,
             'long_description': parse_file,
             'version': self._parse_version,
-            'project_urls': parse_dict,
+            'project_urls': parse_dict_static,
         }
 
     def _parse_version(self, value):
@@ -620,20 +620,19 @@ def _parse_requirements_list(self, label: str, value: str):
         _warn_accidental_env_marker_misconfig(label, value, parsed)
         # Filter it to only include lines that are not comments. `parse_list`
         # will have stripped each line and filtered out empties.
-        return [line for line in parsed if not line.startswith("#")]
+        return _static.Tuple(line for line in parsed if not line.startswith("#"))
 
     @property
     def parsers(self):
         """Metadata item name to parser function mapping."""
         parse_list = self._parse_list
         parse_bool = self._parse_bool
-        parse_dict = self._parse_dict
         parse_cmdclass = self._parse_cmdclass
 
         return {
             'zip_safe': parse_bool,
             'include_package_data': parse_bool,
-            'package_dir': parse_dict,
+            'package_dir': self._parse_dict,
             'scripts': parse_list,
             'eager_resources': parse_list,
             'dependency_links': parse_list,
@@ -650,7 +649,7 @@ def parsers(self):
             'packages': self._parse_packages,
             'entry_points': self._parse_file_in_root,
             'py_modules': parse_list,
-            'python_requires': SpecifierSet,
+            'python_requires': _static.SpeficierSet,
             'cmdclass': parse_cmdclass,
         }
 
@@ -737,7 +736,7 @@ def parse_section_extras_require(self, section_options) -> None:
             lambda k, v: self._parse_requirements_list(f"extras_require[{k}]", v),
         )
 
-        self['extras_require'] = parsed
+        self['extras_require'] = _static.Mapping(parsed)
 
     def parse_section_data_files(self, section_options) -> None:
         """Parses `data_files` configuration file section.

setuptools/dist.py

@@ -19,6 +19,7 @@
 from . import (
     _entry_points,
     _reqs,
+    _static,
     command as _,  # noqa: F401 # imported for side-effects
 )
 from ._importlib import metadata
@@ -391,10 +392,15 @@ def _normalize_requires(self):
         """Make sure requirement-related attributes exist and are normalized"""
         install_requires = getattr(self, "install_requires", None) or []
         extras_require = getattr(self, "extras_require", None) or {}
-        self.install_requires = list(map(str, _reqs.parse(install_requires)))
-        self.extras_require = {
-            k: list(map(str, _reqs.parse(v or []))) for k, v in extras_require.items()
-        }
+
+        # Preserve the "static"-ness of values parsed from config files
+        seq = _static.Tuple if isinstance(install_requires, _static.Static) else list
+        self.install_requires = seq(map(str, _reqs.parse(install_requires)))
+
+        mapp = _static.Mapping if isinstance(extras_require, _static.Static) else dict
+        self.extras_require = mapp(
+            (k, list(map(str, _reqs.parse(v or [])))) for k, v in extras_require.items()
+        )
 
     def _finalize_license_files(self) -> None:
         """Compute names of all license files which should be included."""

setuptools/monkey.py

@@ -89,6 +89,19 @@ def patch_all():
             'distutils.command.build_ext'
         ].Extension = setuptools.extension.Extension
 
+    if hasattr(distutils.dist, '_ensure_list'):
+        from . import _static
+
+        ensure_list = distutils.dist._ensure_list
+
+        def _ensure_list_accept_static(value, fieldname):
+            if isinstance(value, _static.Static):
+                return value
+
+            return ensure_list(value, fieldname)
+
+        patch_func(_ensure_list_accept_static, distutils.dist, '_ensure_list')
+
 
 def _patch_distribution_metadata():
     from . import _core_metadata

setuptools/tests/test_egg_info.py

@@ -517,7 +517,7 @@ def test_provides_extra(self, tmpdir_cwd, env):
         with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp:
             pkg_info_lines = fp.read().split('\n')
         assert 'Provides-Extra: foobar' in pkg_info_lines
-        assert 'Metadata-Version: 2.1' in pkg_info_lines
+        assert 'Metadata-Version: 2.2' in pkg_info_lines
 
     def test_doesnt_provides_extra(self, tmpdir_cwd, env):
         self._setup_script_with_requires(