Please address the comments from this code review:

## Overall Comments
- Using a cached_property for `_files_and_version` means the file list and version are frozen at first access; if new artifacts are added to the dist directory later in the same process (outside the explicit re-creation in `publish`), the uploader may operate on stale data, so consider either avoiding caching or tying the cache invalidation explicitly to build/publish lifecycle events.
- The version extraction logic in `_files_and_version` relies on specific filename patterns and string operations on `stem` (including `.removesuffix('.tar')` and a split on `-`), which may be brittle for alternative distribution formats or unusual version tags; it might be safer to centralize and/or unit-test this parsing against a broader set of real-world filenames.
- In `_register`, using `self.files[0]` assumes that at least one artifact exists and that the first one is appropriate for registration; it might be clearer and more robust to explicitly select an sdist if present and to fail fast with a descriptive error if no matching artifacts are found.

## Individual Comments

### Comment 1
<location> `tests/publishing/test_uploader.py:35-42` </location>
<code_context>
+    return Uploader(poetry, NullIO())
+
+
[email protected](
+    ("files", "expected_files", "expected_version"),
+    [
+        (
+            ["simple_project-1.2.3.tar.gz", "simple_project-1.2.3-py3-none-any.whl"],
+            ["simple_project-1.2.3.tar.gz", "simple_project-1.2.3-py3-none-any.whl"],
+            "1.2.3",
+        ),
+        (  # other names are ignored
+            [
</code_context>

<issue_to_address>
**suggestion (testing):** Extend `test_uploader_files_only_latest` parametrization to cover empty dist and pre-release version ordering.

To exercise `_files_and_version` more thoroughly, consider adding two parameter sets:

1. Empty dist directory: no matching artifacts, expecting `uploader.files == []` and `uploader.version == ""` to cover the `case 0` branch.
2. Pre-release vs final: e.g. `1.2.3rc1` and `1.2.3`, asserting that `1.2.3` is selected to confirm `Version.parse` ordering and correct handling of pre-releases in the new dynamic resolution.

These will round out the spec for the artifact selection logic.

Suggested implementation:

```python
@pytest.fixture
def uploader(poetry: Poetry) -> Uploader:
    return Uploader(poetry, NullIO())


@pytest.mark.parametrize(
    ("files", "expected_files", "expected_version"),
    [
        (
            ["simple_project-1.2.3.tar.gz", "simple_project-1.2.3-py3-none-any.whl"],
            ["simple_project-1.2.3.tar.gz", "simple_project-1.2.3-py3-none-any.whl"],
            "1.2.3",
        ),
        (  # empty dist directory -> no files, no version
            [],
            [],
            "",
        ),
        (  # pre-release vs final: final wins
            [
                "simple_project-1.2.3rc1.tar.gz",
                "simple_project-1.2.3rc1-py3-none-any.whl",
                "simple_project-1.2.3.tar.gz",
                "simple_project-1.2.3-py3-none-any.whl",
            ],
           [
               "simple_project-1.2.3.tar.gz",
               "simple_project-1.2.3-py3-none-any.whl",
           ],
            "1.2.3",
        ),
        (  # other names are ignored
            [
                "simple_project-1.2.3.tar.gz",
                "other_project-1.2.3.tar.gz",
                "simple_project-1.2.3-py3-none-any.whl",

```

I assumed that:
- These parametrized values are consumed by `test_uploader_files_only_latest` (or similar) and that `expected_files` and `expected_version` are asserted against `uploader.files` and `uploader.version`.
- The empty dist case is represented by passing an empty `files` list into the test, which should exercise the branch where `_files_and_version` yields no version (`""`) and an empty file list.
- The pre-release vs final case is meant to assert that when both `1.2.3rc1` and `1.2.3` artifacts exist, only the `1.2.3` artifacts are selected, confirming that `Version.parse` ranks the final release higher than the pre-release.

If the test currently derives `files` from an actual directory rather than directly from this `files` argument, you may need to:
1. Ensure the test uses the `files` param to set up the dist directory contents (e.g. by touching files in a tmp path).
2. Confirm that the no-files case leads to `uploader.version == ""` (or adjust `expected_version` if the implementation uses `None` or some other sentinel).
</issue_to_address>

### Comment 2
<location> `tests/publishing/test_uploader.py:194-203` </location>
<code_context>


 def test_uploader_registers_for_appropriate_400_errors(
-    mocker: MockerFixture, http: responses.RequestsMock, uploader: Uploader
+    http: responses.RequestsMock, uploader: Uploader
 ) -> None:
-    register = mocker.patch("poetry.publishing.uploader.Uploader._register")
     http.post("https://foo.com", status=400, body="No package was ever registered")

     with pytest.raises(UploadError):
         uploader.upload("https://foo.com")

-    assert register.call_count == 1
+    assert len(http.calls) == 2
+    assert b'name=":action"\r\n\r\nfile_upload\r\n' in (
+        http.calls[0].request.body or b""
+    )
+    assert b'name=":action"\r\n\r\nsubmit\r\n' in (http.calls[1].request.body or b"")


</code_context>

<issue_to_address>
**suggestion (testing):** Add a dedicated test for `_register` behavior when only wheel artifacts are present.

The new assertions on `http.calls` improve verification of the registration flow, but `_register` now uses `self.files[0]` instead of a specific sdist path. This changes behavior when only wheels exist: previously `_register` failed due to missing sdist; now it will register using the first file (a wheel).

Please add a dedicated test (e.g. `test_uploader_register_uses_wheel_if_no_sdist`) that:
- populates `dist_dir` with only a wheel for the latest version,
- triggers `_register` (directly or via the 400 upload flow), and
- asserts that the wheel is used (via `post_data` or `http.calls`).

This will document and lock in the new behavior when no sdist is available.

Suggested implementation:

```python
def test_uploader_properly_handles_400_errors(




def test_uploader_register_uses_wheel_if_no_sdist(
    http: responses.RequestsMock,
    poetry: "Poetry",
    tmp_path: "Path",
) -> None:
    wheel = tmp_path / "foo-1.2.3-py3-none-any.whl"
    wheel.write_bytes(b"wheel-binary")

    uploader = Uploader(poetry, NullIO(), dist_dir=tmp_path)

    http.post("https://foo.com", status=400, body="No package was ever registered")

    with pytest.raises(UploadError):
        uploader.upload("https://foo.com")

    assert len(http.calls) == 2

    wheel_name = wheel.name.encode()
    assert wheel_name in (http.calls[0].request.body or b"")
    assert wheel_name in (http.calls[1].request.body or b"")


if TYPE_CHECKING:

```

This new test assumes:

1. `Uploader`, `UploadError`, `NullIO`, and `pytest` are already imported at the top of `tests/publishing/test_uploader.py`, consistent with the rest of the test file.
2. The `http` fixture of type `responses.RequestsMock`, the `poetry` fixture of type `Poetry`, and the `tmp_path` fixture are already available (which is typical for this test module).
3. The registry URL `"https://foo.com"` matches the one used in the other uploader tests, so that the `responses` mock intercepts the calls.

If the actual filename pattern for the wheel differs (e.g. project name or version), adjust `"foo-1.2.3-py3-none-any.whl"` accordingly to match what `poetry` produces for the latest version in your fixtures.
</issue_to_address>

### Comment 3
<location> `tests/publishing/test_publisher.py:53` </location>
<code_context>
     config: Config,
     fixture_name: str,
 ) -> None:
+    mocker.patch("poetry.publishing.uploader.Uploader.version", "1.2.3")
     uploader_auth = mocker.patch("poetry.publishing.uploader.Uploader.auth")
     uploader_upload = mocker.patch("poetry.publishing.uploader.Uploader.upload")
</code_context>

<issue_to_address>
**suggestion (testing):** Strengthen publisher test to assert the printed version matches the uploader's dynamic version.

Patching `Uploader.version` stabilizes the version used in the test, but it doesn’t yet verify the new behavior. Please extend this test (or add a sibling) to assert on the captured console output after running the command—for example, that it includes `Publishing simple-project (1.2.3) to ...`—so we confirm the publisher is actually using `self._uploader.version` rather than the static package version.

Suggested implementation:

```python
    config: Config,
    fixture_name: str,
    capsys: CaptureFixture[str],
) -> None:
    mocker.patch("poetry.publishing.uploader.Uploader.version", "1.2.3")
    uploader_auth = mocker.patch("poetry.publishing.uploader.Uploader.auth")
    uploader_upload = mocker.patch("poetry.publishing.uploader.Uploader.upload")

    # After running the publish command, ensure we printed the uploader's version
    captured = capsys.readouterr()
    assert "Publishing simple-project (1.2.3) to " in captured.out

```

To make this compile and behave correctly, a couple of surrounding adjustments are likely needed:

1. **Import the capture fixture type**  
   At the top of `tests/publishing/test_publisher.py`, add:
   ```python
   from pytest import CaptureFixture
   ```
   (or `import pytest` and then use `pytest.CaptureFixture[str]` in the signature, depending on existing conventions in this file).

2. **Place the assertion after the publish command is executed**  
   The assertion added above must run *after* whatever code actually triggers the publishing (e.g., a CLI runner, command tester, or direct `Publisher.publish()` call).  
   If the publish command is currently invoked *after* the snippet you provided, you should move the `captured = capsys.readouterr()` and `assert ...` lines to immediately after that invocation. For example:
   ```python
   # existing code that triggers the publish (example)
   result = app.invoke(["publish"])

   captured = capsys.readouterr()
   assert "Publishing simple-project (1.2.3) to " in captured.out
   ```

3. **Ensure the project name matches**  
   If the fixture under test uses a different project name than `"simple-project"`, update the expected string to match the actual project name that appears in the publish message (keeping `(1.2.3)` as the version).

These adjustments will ensure the test both stabilizes the uploader version and verifies that the publisher’s user-facing output reflects `self._uploader.version`.
</issue_to_address>