WIP: adding recent changes to tests

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

pyproject.toml

@@ -60,6 +60,7 @@ ignore-words-list = [
 [tool.coverage.run]
 branch = true
 source_pkgs = ["packaging"]
+omit = ["src/packaging/project_table.py"]
 
 [tool.coverage.report]
 show_missing = true

src/packaging/_pyproject.py

@@ -72,8 +72,10 @@ def ensure_str(self, value: str, key: str) -> str | None:
         self.config_error(msg, key=key, got_type=type(value))
         return None
 
-    def ensure_list(self, val: list[T], key: str) -> list[T] | None:
+    def ensure_list(self, val: list[T] | None, key: str) -> list[T] | None:
         """Ensure that a value is a list of strings."""
+        if val is None:
+            return None
         if not isinstance(val, list):
             msg = "Field {key} has an invalid type, expecting a list of strings"
             self.config_error(msg, key=key, got_type=type(val))

src/packaging/errors.py

@@ -3,10 +3,11 @@
 import contextlib
 import dataclasses
 import sys
-from typing import TYPE_CHECKING, Any
+import typing
 
-if TYPE_CHECKING:
+if typing.TYPE_CHECKING:
     from collections.abc import Generator
+    from typing import Any
 
 __all__ = ["ConfigurationError", "ConfigurationWarning", "ExceptionGroup"]
 

src/packaging/metadata.py

@@ -7,7 +7,6 @@
 import email.policy
 import keyword
 import pathlib
-import sys
 import typing
 from typing import (
     Any,
@@ -29,28 +28,6 @@
 T = typing.TypeVar("T")
 
 
-if sys.version_info >= (3, 11):  # pragma: no cover
-    ExceptionGroup = ExceptionGroup
-else:  # pragma: no cover
-
-    class ExceptionGroup(Exception):  # type: ignore[no-redef]
-        """A minimal implementation of :external:exc:`ExceptionGroup` from Python 3.11.
-
-        If :external:exc:`ExceptionGroup` is already defined by Python itself,
-        that version is used instead.
-        """
-
-        message: str
-        exceptions: list[Exception]
-
-        def __init__(self, message: str, exceptions: list[Exception]) -> None:
-            self.message = message
-            self.exceptions = exceptions
-
-        def __repr__(self) -> str:
-            return f"{self.__class__.__name__}({self.message!r}, {self.exceptions!r})"
-
-
 class InvalidMetadata(ValueError):
     """A metadata field contains invalid data."""
 
@@ -746,6 +723,8 @@ def _process_import_names(self, value: list[str]) -> list[str]:
             name, semicolon, private = import_name.partition(";")
             name = name.rstrip()
             for identifier in name.split("."):
+                if identifier == "":
+                    continue
                 if not identifier.isidentifier():
                     raise self._invalid_metadata(
                         f"{name!r} is invalid for {{field}}; "

src/packaging/project.py

@@ -9,6 +9,8 @@
 import email.message
 import email.policy
 import email.utils
+import itertools
+import keyword
 import os
 import os.path
 import pathlib
@@ -23,7 +25,7 @@
 
 if typing.TYPE_CHECKING:  # pragma: no cover
     import sys
-    from collections.abc import Mapping, Sequence
+    from collections.abc import Generator, Mapping, Sequence
     from typing import Any
 
     from .requirements import Requirement
@@ -55,6 +57,8 @@
     "dynamic",
     "entry-points",
     "gui-scripts",
+    "import-names",
+    "import-namespaces",
     "keywords",
     "license",
     "license-files",
@@ -68,6 +72,7 @@
     "version",
 }
 PRE_SPDX_METADATA_VERSIONS = {"2.1", "2.2", "2.3"}
+PRE_2_5_METADATA_VERSIONS = {"2.1", "2.2", "2.3", "2.4"}
 
 
 def extras_top_level(pyproject_table: Mapping[str, Any]) -> set[str]:
@@ -91,12 +96,55 @@ def extras_project(pyproject_table: Mapping[str, Any]) -> set[str]:
     return set(pyproject_table.get("project", [])) - KNOWN_PROJECT_FIELDS
 
 
+def _validate_import_names(
+    names: list[str], key: str, *, errors: ErrorCollector
+) -> Generator[str, None, None]:
+    """
+    Returns normalized names for comparisons.
+    """
+    for fullname in names:
+        name, simicolon, private = fullname.partition(";")
+        if simicolon and private.lstrip() != "private":
+            msg = "{key} contains an ending tag other than '; private', got {value!r}"
+            errors.config_error(msg, key=key, value=fullname)
+        name = name.rstrip()
+
+        for ident in name.split("."):
+            if not ident.isidentifier():
+                msg = "{key} contains {value!r}, which is not a valid identifier"
+                errors.config_error(msg, key=key, value=fullname)
+
+            elif keyword.iskeyword(ident):
+                msg = (
+                    "{key} contains a Python keyword,"
+                    " which is not a valid import name, got {value!r}"
+                )
+                errors.config_error(msg, key=key, value=fullname)
+
+        yield name
+
+
+def _validate_dotted_names(names: set[str], *, errors: ErrorCollector) -> None:
+    """
+    Checks to make sure every name is accounted for. Takes the union of de-tagged names.
+    """
+
+    for name in names:
+        for parent in itertools.accumulate(
+            name.split(".")[:-1], lambda a, b: f"{a}.{b}"
+        ):
+            if parent not in names:
+                msg = "{key} is missing {value!r}, but submodules are present elsewhere"
+                errors.config_error(msg, key="project.import-namespaces", value=parent)
+                continue
+
+
 @dataclasses.dataclass
 class StandardMetadata:
     """
     This class represents the standard metadata fields for a project. It can be
     used to read metadata from a pyproject.toml table, validate it, and write it
-    to an RFC822 message or JSON.
+    to an RFC822 message.
     """
 
     name: str
@@ -118,6 +166,8 @@ class StandardMetadata:
     keywords: list[str] = dataclasses.field(default_factory=list)
     scripts: dict[str, str] = dataclasses.field(default_factory=dict)
     gui_scripts: dict[str, str] = dataclasses.field(default_factory=dict)
+    import_names: list[str] | None = None
+    import_namespaces: list[str] | None = None
     dynamic: list[Dynamic] = dataclasses.field(default_factory=list)
     """
     This field is used to track dynamic fields. You can't set a field not in this list.
@@ -273,14 +323,31 @@ def from_pyproject(
                     project.get("gui-scripts", {}), "project.gui-scripts"
                 )
                 or {},
+                import_names=pyproject.ensure_list(
+                    project.get("import-names", None), "project.import-names"
+                ),
+                import_namespaces=pyproject.ensure_list(
+                    project.get("import-namespaces", None), "project.import-namespaces"
+                ),
                 dynamic=dynamic,
             )
 
         pyproject.finalize("Failed to parse pyproject.toml")
         assert self is not None
         return self
 
-    def validate_metdata(self, metadata_version: str) -> None:
+    def validate_metadata(self, metadata_version: str) -> None:
+        """
+        Validate metadata for consistency and correctness given a metadata
+        version. This is called when making metadata. Checks:
+
+        - ``license`` is not an SPDX license expression if metadata_version
+          >= 2.4 (warning)
+        - License classifiers deprecated for metadata_version >= 2.4 (warning)
+        - ``license`` is an SPDX license expression if metadata_version >= 2.4
+        - ``license_files`` is supported only for metadata_version >= 2.4
+        - ``import-name(paces)s`` is only supported on metadata_version >= 2.5
+        """
         errors = ErrorCollector()
 
         if not self.version:
@@ -317,28 +384,37 @@ def validate_metdata(self, metadata_version: str) -> None:
             self.license_files is not None
             and metadata_version in PRE_SPDX_METADATA_VERSIONS
         ):
-            msg = "{key} is supported only when emitting metadata version >= 2.4"
+            msg = "{key} is only supported when emitting metadata version >= 2.4"
             errors.config_error(msg, key="project.license-files")
 
+        if (
+            self.import_names is not None
+            and metadata_version in PRE_2_5_METADATA_VERSIONS
+        ):
+            msg = "{key} is only supported when emitting metadata version >= 2.5"
+            errors.config_error(msg, key="project.import-names")
+
+        if (
+            self.import_namespaces is not None
+            and metadata_version in PRE_2_5_METADATA_VERSIONS
+        ):
+            msg = "{key} is only supported when emitting metadata version >= 2.5"
+            errors.config_error(msg, key="project.import-namespaces")
+
         errors.finalize("Metadata validation failed")
 
     def validate(self) -> None:
         """
-        Validate metadata for consistency and correctness. Will also produce
-        warnings if ``warn`` is given. Respects ``all_errors``. This is called
-        when loading a pyproject.toml, and when making metadata. Checks:
+        Validate metadata for consistency and correctness. This is called
+        when loading a pyproject.toml. Checks:
 
-        - ``metadata_version`` is a known version or None
         - ``name`` is a valid project name
         - ``license_files`` can't be used with classic ``license``
         - License classifiers can't be used with SPDX license
         - ``description`` is a single line (warning)
-        - ``license`` is not an SPDX license expression if metadata_version
-          >= 2.4 (warning)
-        - License classifiers deprecated for metadata_version >= 2.4 (warning)
-        - ``license`` is an SPDX license expression if metadata_version >= 2.4
-        - ``license_files`` is supported only for metadata_version >= 2.4
         - ``project_url`` can't contain keys over 32 characters
+        - ``import-name(space)s`` must be valid names, optionally with ``; private``
+        - ``import-names`` and ``import-namespaces`` cannot overlap
         """
         errors = ErrorCollector()
 
@@ -380,6 +456,23 @@ def validate(self) -> None:
                 msg = "{key} names cannot be more than 32 characters long"
                 errors.config_error(msg, key="project.urls", got=name)
 
+        import_names = set(
+            _validate_import_names(
+                self.import_names or [], "import-names", errors=errors
+            )
+        )
+        import_namespaces = set(
+            _validate_import_names(
+                self.import_namespaces or [], "import-namespaces", errors=errors
+            )
+        )
+        in_both = import_names & import_namespaces
+        if in_both:
+            msg = "{key} overlaps with 'project.import-namespaces': {in_both}"
+            errors.config_error(msg, key="project.import-names", in_both=in_both)
+
+        _validate_dotted_names(import_names | import_namespaces, errors=errors)
+
         errors.finalize("[project] table validation failed")
 
     def metadata(
@@ -388,7 +481,7 @@ def metadata(
         """
         Return an Message with the metadata.
         """
-        self.validate_metdata(metadata_version)
+        self.validate_metadata(metadata_version)
 
         assert self.version is not None
         message = packaging_metadata.RawMetadata(
@@ -452,9 +545,19 @@ def metadata(
                 for requirement in requirements
             )
         if self.readme:
-            if self.readme.content_type:
-                message["description_content_type"] = self.readme.content_type
+            assert self.readme.content_type  # verified earlier
+            message["description_content_type"] = self.readme.content_type
             message["description"] = self.readme.text
+
+        if self.import_names is not None:
+            # Special case for empty import-names
+            if not self.import_names:
+                message["import_names"] = [""]
+            else:
+                message["import_names"] = self.import_names
+        if self.import_namespaces is not None:
+            message["import_namespaces"] = self.import_namespaces
+
         # Core Metadata 2.2
         if metadata_version != "2.1":
             for field in dynamic_metadata:

src/packaging/project_table.py

@@ -52,6 +52,8 @@ class LicenseTable(TypedDict, total=False):
     "dynamic",
     "entry-points",
     "gui-scripts",
+    "import-names",
+    "import-namespaces",
     "keywords",
     "license",
     "maintainers",
@@ -83,6 +85,8 @@ class LicenseTable(TypedDict, total=False):
         "keywords": List[str],
         "scripts": Dict[str, str],
         "gui-scripts": Dict[str, str],
+        "import-names": List[str],
+        "import-namespaces": List[str],
         "dynamic": List[Dynamic],
     },
     total=False,

tests/project/full-metadata/pyproject.toml

@@ -10,6 +10,7 @@ authors = [
     { name = 'Example!' },
 ]
 maintainers = [
+    { name = 'Emailless' },
     { name = 'Other Example', email = '[email protected]' },
 ]
 classifiers = [

tests/project/metadata-2.5/LICENSE

@@ -0,0 +1,20 @@
+Copyright © 2019 Filipe Laíns <[email protected]>
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

tests/project/metadata-2.5/README.md

@@ -0,0 +1 @@
+some readme 👋