fix: uv cannot lock a project that declares no name or version

uv requires project.name and project.version, while PDM allows an
application to omit both. The generated pyproject.toml omitted them too,
so uv failed to parse it. A placeholder is written instead, and the
resulting root entry is filtered out again when the lockfile is read
back so it never reaches pdm.lock.

Fixes #3421

Author: VXNCXNX

news/3849.bugfix.md

@@ -0,0 +1 @@
+Fill in a placeholder `project.name` and `project.version` for the `pyproject.toml` generated for `uv`, so `pdm lock`/`pdm install` work with `use_uv` on a project that declares neither.

src/pdm/formats/uv.py

@@ -17,6 +17,13 @@
 from pdm.project.core import Project
 from pdm.utils import get_requirement_from_override, normalize_name
 
+#: uv requires ``project.name`` and ``project.version`` to be present, while PDM allows a
+#: project without them (an "application"). In that case a placeholder is written to the
+#: generated ``pyproject.toml`` and the resulting root entry is filtered out again when the
+#: uv lockfile is read back.
+PLACEHOLDER_NAME = "pdm-placeholder-project"
+PLACEHOLDER_VERSION = "0.0.0"
+
 
 @dataclass
 class _UvFileBuilder:
@@ -57,6 +64,10 @@ def build_pyproject_toml(self) -> Path:
             )
 
         data.setdefault("project", {})["requires-python"] = self.requires_python
+        if not data["project"].get("name"):
+            data["project"]["name"] = PLACEHOLDER_NAME
+        if not data["project"].get("version") and "version" not in data["project"].get("dynamic", []):
+            data["project"]["version"] = PLACEHOLDER_VERSION
         data.pop("dependency-groups", None)
         data.setdefault("project", {}).pop("optional-dependencies", None)
         if self.workspace_members:
@@ -116,30 +127,30 @@ def build_uv_lock(self, include_self: bool = False) -> Path:
                 p for k, p in locked_repo.packages.items() if strip_extras(k[0])[0] == key[0] and k[1:] == key[1:]
             ]
             packages.append(self._build_lock_entry(related_packages))
-        if name := self.project.name:
-            version = self.project.pyproject.metadata.get("version", "0.0.0")
-            this_package = {
-                "name": normalize_name(name),
-                "version": version,
-                "source": {"editable" if include_self else "virtual": "."},
-            }
-            dependencies: list[dict[str, Any]] = []
-            optional_dependencies: dict[str, list[dict[str, Any]]] = {}
-            for req in self.requirements:
-                if (dep := self._make_dependency(None, req)) is None:
-                    continue
-                for group in req.groups:
-                    if group == "default":
-                        target_group = dependencies
-                    else:
-                        target_group = optional_dependencies.setdefault(group, [])
-                    if dep not in target_group:
-                        target_group.append(dep)
-            if dependencies:
-                this_package["dependencies"] = dependencies  # type: ignore[assignment]
-            if optional_dependencies:
-                this_package["optional-dependencies"] = optional_dependencies
-            packages.append(this_package)
+        name = self.project.name or PLACEHOLDER_NAME
+        version = self.project.pyproject.metadata.get("version") or PLACEHOLDER_VERSION
+        this_package = {
+            "name": normalize_name(name),
+            "version": version,
+            "source": {"editable" if include_self else "virtual": "."},
+        }
+        dependencies: list[dict[str, Any]] = []
+        optional_dependencies: dict[str, list[dict[str, Any]]] = {}
+        for req in self.requirements:
+            if (dep := self._make_dependency(None, req)) is None:
+                continue
+            for group in req.groups:
+                if group == "default":
+                    target_group = dependencies
+                else:
+                    target_group = optional_dependencies.setdefault(group, [])
+                if dep not in target_group:
+                    target_group.append(dep)
+        if dependencies:
+            this_package["dependencies"] = dependencies  # type: ignore[assignment]
+        if optional_dependencies:
+            this_package["optional-dependencies"] = optional_dependencies
+        packages.append(this_package)
 
         data = {"version": 1, "requires-python": self.requires_python}
         if packages:

src/pdm/resolver/uv.py

@@ -114,6 +114,7 @@ def _parse_uv_lock(self, path: Path) -> Resolution:
         from unearth import Link
 
         from pdm.compat import tomllib
+        from pdm.formats.uv import PLACEHOLDER_NAME
 
         with path.open("rb") as f:
             data = tomllib.load(f)
@@ -142,12 +143,11 @@ def make_hash(item: dict[str, Any], fallback_url: str | None = None) -> FileHash
                 hash_value = hash_cache.get_hash(link, session)
             return {"url": url, "file": link.filename, "hash": hash_value}
 
+        # When the project has no `name`, a placeholder is written to the generated
+        # pyproject.toml, so the root entry comes back under that name.
+        self_name = normalize_name(self.project.name) if self.project.name else PLACEHOLDER_NAME
         for package in data["package"]:
-            if (
-                self.project.name
-                and package["name"] == normalize_name(self.project.name)
-                and (not self.keep_self or package["source"].get("virtual"))
-            ):
+            if package["name"] == self_name and (not self.keep_self or package["source"].get("virtual")):
                 continue
             req: Requirement
             if url := package["source"].get("url"):

tests/test_formats.py

@@ -129,6 +129,49 @@ def test_build_uv_pyproject_toml_with_workspace(project):
     assert data["tool"]["uv"]["sources"]["bar"] == {"workspace": True}
 
 
+def test_build_uv_files_without_project_name_and_version(project):
+    """uv requires project.name/version, so a placeholder is filled in for applications
+    that declare neither. See issue #3421.
+    """
+    from pdm.formats.uv import PLACEHOLDER_NAME, PLACEHOLDER_VERSION
+
+    del project.pyproject.metadata["name"]
+    del project.pyproject.metadata["version"]
+    project.pyproject.write()
+
+    locked_repo = LockedRepository({}, project.sources, project.environment)
+    with uv_file_builder(project, ">=3.10", [], locked_repo) as builder:
+        pyproject_path = builder.build_pyproject_toml()
+        with pyproject_path.open("rb") as fp:
+            pyproject_data = tomllib.load(fp)
+        lock_path = builder.build_uv_lock()
+        with lock_path.open("rb") as fp:
+            lock_data = tomllib.load(fp)
+
+    # uv refuses to parse a pyproject.toml whose [project] table lacks either key
+    assert pyproject_data["project"].get("name") == PLACEHOLDER_NAME
+    assert pyproject_data["project"].get("version") == PLACEHOLDER_VERSION
+    roots = [p for p in lock_data["package"] if p["name"] == PLACEHOLDER_NAME]
+    assert len(roots) == 1
+    assert roots[0]["version"] == PLACEHOLDER_VERSION
+    assert roots[0]["source"] == {"virtual": "."}
+
+
+def test_build_uv_pyproject_toml_keeps_dynamic_version(project):
+    project.pyproject.metadata["dynamic"] = ["version"]
+    del project.pyproject.metadata["version"]
+    project.pyproject.write()
+
+    locked_repo = LockedRepository({}, project.sources, project.environment)
+    with uv_file_builder(project, ">=3.10", [], locked_repo) as builder:
+        path = builder.build_pyproject_toml()
+        with path.open("rb") as fp:
+            data = tomllib.load(fp)
+
+    assert "version" not in data["project"]
+    assert data["project"]["dynamic"] == ["version"]
+
+
 def test_build_uv_lock_with_local_path_wheel(project):
     from pdm.models.candidates import Candidate
     from pdm.models.repositories import Package