Merge branch 'main' into poetry-documentation-proofread

Author: deronnax

.pre-commit-config.yaml

@@ -28,12 +28,12 @@ repos:
       - id: validate_manifest
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.5
+    rev: v0.11.6
     hooks:
       - id: ruff
       - id: ruff-format
 
   - repo: https://github.com/woodruffw/zizmor-pre-commit
-    rev: v1.5.2
+    rev: v1.6.0
     hooks:
       - id: zizmor

src/poetry/console/application.py

@@ -251,11 +251,11 @@ def _run(self, io: IO) -> int:
         # display the error cleanly unless the user uses verbose or debug
         self._configure_global_options(io)
 
-        self._load_plugins(io)
+        with directory(self._working_directory):
+            self._load_plugins(io)
 
-        exit_code: int = 1
+            exit_code: int = 1
 
-        with directory(self._working_directory):
             try:
                 exit_code = super()._run(io)
             except PoetryRuntimeError as e:

src/poetry/puzzle/provider.py

@@ -30,6 +30,7 @@
 from poetry.packages.direct_origin import DirectOrigin
 from poetry.packages.package_collection import PackageCollection
 from poetry.puzzle.exceptions import OverrideNeededError
+from poetry.repositories.repository_pool import Priority
 from poetry.utils.helpers import get_file_hash
 
 
@@ -753,6 +754,14 @@ def get_locked(self, dependency: Dependency) -> DependencyPackage | None:
             if package.satisfies(dependency):
                 if explicit_source := self._explicit_sources.get(dependency.name):
                     dependency.source_name = explicit_source
+                elif (
+                    not dependency.source_name
+                    and package.source_type == "legacy"
+                    and package.source_reference
+                    and self._pool.get_priority(package.source_reference)
+                    == Priority.EXPLICIT
+                ):
+                    continue
                 return DependencyPackage(dependency, package)
         return None
 

tests/console/test_application_global_options.py

@@ -5,6 +5,7 @@
 
 from pathlib import Path
 from typing import TYPE_CHECKING
+from typing import ClassVar
 
 import pytest
 
@@ -13,7 +14,10 @@
 from cleo.testers.application_tester import ApplicationTester
 
 from poetry.console.application import Application
+from poetry.console.commands.command import Command
 from poetry.console.commands.version import VersionCommand
+from poetry.plugins import ApplicationPlugin
+from tests.helpers import mock_metadata_entry_points
 from tests.helpers import switch_working_directory
 
 
@@ -27,11 +31,58 @@
 NO_PYPROJECT_TOML_ERROR = "Poetry could not find a pyproject.toml file in"
 
 
+class CheckProjectPathCommand(Command):
+    name = "check-project-path"
+
+    description = "Check Project Path Command"
+
+    def handle(self) -> int:
+        if not self.poetry.pyproject_path.exists():
+            raise RuntimeError(
+                f"Wrong project path in handle: {self.poetry.pyproject_path}\nWorking directory: {Path.cwd()}"
+            )
+
+        return 0
+
+
+class EarlyPoetryAccessPlugin(ApplicationPlugin):
+    commands: ClassVar[list[type[Command]]] = [CheckProjectPathCommand]
+
+    def activate(self, application: Application) -> None:
+        super().activate(application)
+
+        # access application.poetry
+        # see https://github.com/nat-n/poethepoet/issues/288
+        if not application.poetry.pyproject_path.exists():
+            raise RuntimeError(
+                f"Wrong project path in activate: {application.poetry.pyproject_path}\nWorking directory: {Path.cwd()}"
+            )
+
+
+@pytest.fixture
+def with_early_poetry_access_plugin(mocker: MockerFixture) -> None:
+    mock_metadata_entry_points(mocker, EarlyPoetryAccessPlugin)
+
+
 @pytest.fixture
 def project_source_directory(fixture_copier: FixtureCopier) -> Path:
     return fixture_copier("up_to_date_lock")
 
 
+@pytest.fixture
+def relative_project_source_directory(project_source_directory: Path) -> Path:
+    # ensure pre-conditions are met
+    cwd = Path.cwd()
+    assert project_source_directory.is_relative_to(cwd)
+
+    # construct relative path
+    relative_source_directory = project_source_directory.relative_to(cwd)
+    assert relative_source_directory.as_posix() != project_source_directory.as_posix()
+    assert not relative_source_directory.is_absolute()
+
+    return relative_source_directory
+
+
 @pytest.fixture
 def tester() -> ApplicationTester:
     return ApplicationTester(Application())
@@ -149,20 +200,14 @@ def test_application_with_context_parameters(
 def test_application_with_relative_project_parameter(
     tester: ApplicationTester,
     project_source_directory: Path,
+    relative_project_source_directory: Path,
     with_mocked_version_command: None,
     tmp_path_factory: TempPathFactory,
 ) -> None:
-    # ensure pre-conditions are met
     cwd = Path.cwd()
-    assert project_source_directory.is_relative_to(cwd)
-
-    # construct relative path
-    relative_source_directory = project_source_directory.relative_to(cwd)
-    assert relative_source_directory.as_posix() != project_source_directory.as_posix()
-    assert not relative_source_directory.is_absolute()
-
-    # we expect application run to be executed within current cwd but project to be a subdirectory
-    args = f"--directory '{cwd}' --project {relative_source_directory} version"
+    # we expect application run to be executed within current cwd
+    # but project to be a subdirectory
+    args = f"--directory '{cwd}' --project {relative_project_source_directory} version"
 
     # we switch cwd to a new temporary directory unrelated to the project directory
     new_working_dir = tmp_path_factory.mktemp("unrelated-working-directory")
@@ -181,6 +226,19 @@ def test_application_with_relative_project_parameter(
         """)
 
 
+def test_application_with_relative_directory_parameter_and_early_poetry_access_plugin(
+    tester: ApplicationTester,
+    with_early_poetry_access_plugin: None,
+    relative_project_source_directory: Path,
+) -> None:
+    """see https://github.com/nat-n/poethepoet/issues/288"""
+    tester.execute(
+        f"--directory {relative_project_source_directory} check-project-path"
+    )
+
+    assert tester.status_code == 0, tester.io.fetch_error()
+
+
 @pytest.mark.parametrize(
     ("parameter", "check", "result"),
     [

tests/helpers.py

@@ -277,10 +277,15 @@ def mock_metadata_entry_points(
     name: str = "my-plugin",
     dist: metadata.Distribution | None = None,
 ) -> None:
+    def patched_entry_points(*args: Any, **kwargs: Any) -> list[metadata.EntryPoint]:
+        if "group" in kwargs and kwargs["group"] != getattr(cls, "group", None):
+            return []
+        return [make_entry_point_from_plugin(name, cls, dist)]
+
     mocker.patch.object(
         metadata,
         "entry_points",
-        return_value=[make_entry_point_from_plugin(name, cls, dist)],
+        side_effect=patched_entry_points,
     )
 
 

tests/plugins/test_plugin_manager.py

@@ -57,6 +57,8 @@ class MyCommandPlugin(ApplicationPlugin):
 
 
 class InvalidPlugin:
+    group = "poetry.plugin"
+
     def activate(self, poetry: Poetry, io: IO) -> None:
         io.write_line("Updating version")
         poetry.package.version = Version.parse("9.9.9")

tests/puzzle/test_solver.py

@@ -3776,6 +3776,83 @@ def test_multiple_constraints_explicit_source_transitive_locked_use_latest(
     assert ops[2].package.source_reference == "explicit2"
 
 
+@pytest.mark.parametrize("locked", [False, True])
+def test_multiple_constraints_incomplete_explicit_source_transitive_locked(
+    package: ProjectPackage,
+    repo: Repository,
+    pool: RepositoryPool,
+    io: NullIO,
+    locked: bool,
+) -> None:
+    """
+    The root package depends on
+     * lib == 1.0+cu ; sys_platform == "linux" with source=explicit
+     * lib == 1.0 ; sys_platform == "darwin" with no explicit source
+     * other >= 1.0
+    "other" depends on "lib"
+
+    Since the source for lib 1.0+cu has the priority "explicit",
+    the default source must be chosen for lib 1.0.
+    Since the multiple constraints are incomplete - they are only defined for linux
+    and darwin, there is another hidden override that also requires lib via other.
+    In this hidden override lib 1.0 from the default source must be chosen
+    (because the other source has the priority "explicit").
+    """
+    package.add_dependency(
+        Factory.create_dependency(
+            "lib",
+            {
+                "version": "1.0+cu",
+                "source": "explicit",
+                "markers": "sys_platform == 'linux'",
+            },
+        )
+    )
+    package.add_dependency(
+        Factory.create_dependency(
+            "lib",
+            {
+                "version": "1.0",
+                "markers": "sys_platform == 'darwin'",
+            },
+        )
+    )
+    package.add_dependency(Factory.create_dependency("other", {"version": ">=1.0"}))
+
+    explicit_repo = Repository("explicit")
+    pool.add_repository(explicit_repo, priority=Priority.EXPLICIT)
+
+    package_lib_explicit = Package(
+        "lib", "1.0+cu", source_type="legacy", source_reference="explicit"
+    )
+    explicit_repo.add_package(package_lib_explicit)
+    package_lib_default = Package("lib", "1.0")
+    repo.add_package(package_lib_default)
+
+    package_other = Package("other", "1.5")
+    package_other.add_dependency(Factory.create_dependency("lib", ">=1.0"))
+    repo.add_package(package_other)
+
+    if locked:
+        # order does not matter because packages are sorted in the provicer
+        # (latest first) so that the package from the explicit source is preferred
+        locked_packages = [package_lib_default, package_lib_explicit, package_other]
+    else:
+        locked_packages = []
+    solver = Solver(package, pool, [], locked_packages, io)
+
+    transaction = solver.solve()
+
+    check_solver_result(
+        transaction,
+        [
+            {"job": "install", "package": package_lib_default},
+            {"job": "install", "package": package_lib_explicit},
+            {"job": "install", "package": package_other},
+        ],
+    )
+
+
 def test_solver_discards_packages_with_empty_markers(
     package: ProjectPackage,
     repo: Repository,