Merge branch 'main' into pre-commit-ci-update-config

Author: Secrus

docs/cli.md

@@ -711,9 +711,15 @@ poetry publish
 It can also build the package if you pass it the `--build` option.
 
 {{% note %}}
-See [Publishable Repositories]({{< relref "repositories/#publishable-repositories" >}}) for more information on how to configure and use publishable repositories.
+See [Publishable Repositories]({{< relref "repositories/#publishable-repositories" >}}) for more information
+on how to configure and use publishable repositories.
 {{% /note %}}
 
+{{% warning %}}
+Only artifacts of the latest version of your package in the dist directory will be uploaded.
+Older versions from previous builds as well as artifacts of other packages are ignored.
+{{% /warning %}}
+
 #### Options
 
 * `--repository (-r)`: The repository to register the package to (default: `pypi`).

poetry.lock

@@ -8,7 +8,7 @@ dependencies = [
     "build (>=1.2.1,<2.0.0)",
     "cachecontrol[filecache] (>=0.14.0,<0.15.0)",
     "cleo (>=2.1.0,<3.0.0)",
-    "dulwich (>=0.24.0,<0.25.0)",
+    "dulwich (>=0.25.0,<0.26.0)",
     "fastjsonschema (>=2.18.0,<3.0.0)",
     "installer (>=0.7.0,<0.8.0)",
     "keyring (>=25.1.0,<26.0.0)",

pyproject.toml

@@ -82,8 +82,9 @@ def handle(self) -> int:
 
             self.call("build", args=f"--output {dist_dir}")
 
-        files = publisher.files
-        if not files:
+            publisher = Publisher(self.poetry, self.io, Path(dist_dir))
+
+        if not publisher.files:
             self.line_error(
                 "<error>No files to publish. "
                 "Run poetry build first or use the --build option.</error>"

src/poetry/console/commands/publish.py

@@ -79,7 +79,7 @@ def publish(
             repository_name = "PyPI"
         self._io.write_line(
             f"Publishing <c1>{self._package.pretty_name}</c1>"
-            f" (<c2>{self._package.pretty_version}</c2>) to"
+            f" (<c2>{self._uploader.version}</c2>) to"
             f" <info>{repository_name}</info>"
         )
 

src/poetry/publishing/publisher.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
+import itertools
 import tarfile
 import zipfile
 
+from collections import defaultdict
+from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING
 from typing import Any
@@ -12,6 +15,7 @@
 
 from packaging.metadata import RawMetadata
 from packaging.metadata import parse_email
+from poetry.core.constraints.version import Version
 from poetry.core.masonry.utils.helpers import distribution_name
 from requests_toolbelt import user_agent
 from requests_toolbelt.multipart import MultipartEncoder
@@ -36,7 +40,7 @@ class UploadError(Exception):
 class Uploader:
     def __init__(self, poetry: Poetry, io: IO, dist_dir: Path | None = None) -> None:
         self._poetry = poetry
-        self._package = poetry.package
+        self._dist_name = distribution_name(poetry.package.name)
         self._io = io
         self._dist_dir = dist_dir or self.default_dist_dir
         self._username: str | None = None
@@ -60,14 +64,39 @@ def dist_dir(self) -> Path:
 
     @property
     def files(self) -> list[Path]:
-        dist = self.dist_dir
-        version = self._package.version.to_string()
-        escaped_name = distribution_name(self._package.name)
+        return self._files_and_version[0]
 
-        wheels = list(dist.glob(f"{escaped_name}-{version}-*.whl"))
-        tars = list(dist.glob(f"{escaped_name}-{version}.tar.gz"))
+    @property
+    def version(self) -> str:
+        return self._files_and_version[1]
 
-        return sorted(wheels + tars)
+    @cached_property
+    def _files_and_version(self) -> tuple[list[Path], str]:
+        dist = self.dist_dir
+
+        wheels = dist.glob(f"{self._dist_name}-*-*.whl")
+        tars = dist.glob(f"{self._dist_name}-*.tar.gz")
+        artifacts_by_version = defaultdict(list)
+        for artifact in itertools.chain(wheels, tars):
+            version = (
+                artifact.stem.removesuffix(".tar")
+                .removeprefix(f"{self._dist_name}-")
+                .split("-", maxsplit=1)[0]
+            )
+            artifacts_by_version[version].append(artifact)
+        match len(artifacts_by_version):
+            case 0:
+                return [], ""
+            case 1:
+                latest_version = next(iter(artifacts_by_version))
+                artifacts = artifacts_by_version[latest_version]
+            case _:
+                latest_version = max(
+                    artifacts_by_version, key=lambda v: Version.parse(v)
+                )
+                artifacts = artifacts_by_version[latest_version]
+
+        return sorted(artifacts, key=lambda a: (a.suffix == ".whl", a)), latest_version
 
     def auth(self, username: str | None, password: str | None) -> None:
         self._username = username
@@ -258,14 +287,7 @@ def _register(self, session: requests.Session, url: str) -> requests.Response:
         """
         Register a package to a repository.
         """
-        dist = self.dist_dir
-        escaped_name = distribution_name(self._package.name)
-        file = dist / f"{escaped_name}-{self._package.version.to_string()}.tar.gz"
-
-        if not file.exists():
-            raise RuntimeError(f'"{file.name}" does not exist.')
-
-        data = self.post_data(file)
+        data = self.post_data(self.files[0])
         data.update({":action": "submit", "protocol_version": "1"})
 
         data_to_send = self._prepare_data(data)

src/poetry/publishing/uploader.py

@@ -151,6 +151,7 @@ def __init__(
             )
 
         self.get_package_from_pool = functools.cache(self._pool.package)
+        self._refreshed: set[tuple[str, Version, str | None]] = set()
 
     @property
     def pool(self) -> RepositoryPool:
@@ -471,14 +472,34 @@ def complete_package(
         elif package.is_direct_origin():
             requires = package.requires
         else:
-            dependency_package = DependencyPackage(
-                dependency,
-                self.get_package_from_pool(
+            if (
+                package.pretty_name,
+                package.version,
+                dependency.source_name,
+            ) in self._refreshed:
+                # circumvent lru_cache to avoid unnecessary refresh
+                pool_package = self.pool.package(
                     package.pretty_name,
                     package.version,
                     repository_name=dependency.source_name,
-                ),
-            )
+                )
+            else:
+                pool_package = self.get_package_from_pool(
+                    package.pretty_name,
+                    package.version,
+                    repository_name=dependency.source_name,
+                )
+            if package.files and sorted(
+                package.files, key=lambda f: f["file"]
+            ) != sorted(pool_package.files, key=lambda f: f["file"]):
+                # This happens if additional artifacts are uploaded later. Either our own cache
+                # is outdated or the lockfile has been created with an outdated cache.
+                # Refresh to cover the first case. (It does not hurt much in the second case.)
+                pool_package = self.pool.refresh(pool_package)
+                self._refreshed.add(
+                    (package.pretty_name, package.version, dependency.source_name)
+                )
+            dependency_package = DependencyPackage(dependency, pool_package)
 
             package = dependency_package.package
             dependency = dependency_package.dependency

src/poetry/puzzle/provider.py

@@ -70,3 +70,6 @@ def package(self, name: str, version: Version) -> Package:
         return self.get_release_info(canonicalize_name(name), version).to_package(
             name=name
         )
+
+    def forget(self, name: str, version: Version) -> None:
+        self._release_cache.forget(f"{canonicalize_name(name)}:{version}")

src/poetry/repositories/cached_repository.py

@@ -9,6 +9,7 @@
 
 from poetry.config.config import Config
 from poetry.repositories.abstract_repository import AbstractRepository
+from poetry.repositories.cached_repository import CachedRepository
 from poetry.repositories.exceptions import PackageNotFoundError
 from poetry.repositories.repository import Repository
 from poetry.utils.cache import ArtifactCache
@@ -181,3 +182,10 @@ def search(self, query: str | list[str]) -> list[Package]:
         for repo in self.repositories:
             results += repo.search(query)
         return results
+
+    def refresh(self, package: Package) -> Package:
+        repository_name = package.source_reference or "PyPI"
+        repo = self.repository(repository_name)
+        if isinstance(repo, CachedRepository):
+            repo.forget(package.name, package.version)
+        return repo.package(package.name, package.version)