python-poetry-poetry-8517

-rw-r--r-- 1 root root   1070 Oct  1 00:41 LICENSE
-rw-r--r-- 1 root root   4662 Oct  1 00:41 README.md
drwxr-xr-x 1 root root   4096 Oct  1 00:41 assets
drwxr-xr-x 1 root root   4096 Oct  1 00:41 docs
-rw-r--r-- 1 root root 129462 Oct  1 00:41 poetry.lock
-rw-r--r-- 1 root root   5251 Oct  1 00:41 pyproject.toml
drwxr-xr-x 1 root root   4096 Oct  1 00:41 src
drwxr-xr-x 1 root root   4096 Oct  1 00:41 tests
bash: line 6: rg: command not found

src/poetry/layouts/__init__.py
src/poetry/layouts/layout.py
src/poetry/layouts/src.py
src/poetry/layouts/standard.py
src/poetry/locations.py
src/poetry/masonry/__init__.py
src/poetry/masonry/api.py
src/poetry/masonry/builders/__init__.py
src/poetry/masonry/builders/editable.py
src/poetry/mixology/__init__.py
src/poetry/mixology/assignment.py
src/poetry/mixology/failure.py

from typing import Generic
from typing import TypeVar

from poetry.utils._compat import decode
from poetry.utils._compat import encode
from poetry.utils.wheel import InvalidWheelName
from poetry.utils.wheel import Wheel


if TYPE_CHECKING:
    from collections.abc import Callable

    from poetry.core.packages.utils.link import Link

    from poetry.utils.env import Env


# Used by FileCache for items that do not expire.
MAX_DATE = 9999999999
T = TypeVar("T")

logger = logging.getLogger(__name__)


def _expiration(minutes: int) -> int:
    """
    Calculates the time in seconds since epoch that occurs 'minutes' from now.

    :param minutes: The number of minutes to count forward
   
…[8629 chars omitted]…
     ],
    )

    archive = cache.get_cached_archive_for_link(Link(link), strict=strict, env=env)

    assert Path(cached) == archive


def test_get_cached_archive_for_git() -> None:
    """Smoke test that checks that no assertion is raised."""
    cache = ArtifactCache(cache_dir=Path())
    archive = cache.get_cached_archive_for_git("url", "ref", "subdirectory", MockEnv())
    assert archive is None

class ArtifactCache:
    def __init__(self, *, cache_dir: Path) -> None:
        self._cache_dir = cache_dir

    def get_cache_directory_for_link(self, link: Link) -> Path:
        key_parts = {"url": link.url_without_fragment}

        if link.hash_name is not None and link.hash is not None:
            key_parts[link.hash_name] = link.hash

        if link.subdirectory_fragment:
            key_parts["subdirectory"] = link.subdirectory_fragment

        return self._get_directory_
…[8196 chars omitted]…
src/poetry/installation/executor.py:759:                original_archive = self._download_archive(operation, link)
src/poetry/installation/executor.py:818:    def _download_archive(self, operation: Install | Update, link: Link) -> Path:
src/poetry/packages/direct_origin.py:12:from poetry.utils.helpers import download_file
src/poetry/packages/direct_origin.py:86:            download_file(url, artifact)

                f"Hash for {package} from archive {archive.name} not found in"
                f" known hashes (was: {archive_hash})"
            )

        return archive_hash

    def _download_archive(self, operation: Install | Update, link: Link) -> Path:
        response = self._authent
…[1741 chars omitted]…
 strict=True)
tests/utils/test_cache.py:263:    archive = cache.get_cached_archive_for_link(Link(link), strict=strict, env=env)
tests/utils/test_cache.py:320:    archive = cache.get_cached_archive_for_link(Link(link), strict=strict, env=env)
[tool.pytest.ini_options]
addopts = "-n auto"
testpaths = ["tests"]
markers = [
    "network: mark tests that require internet access",
]


[tool.coverage.report]

from typing import TYPE_CHECKING
from typing import Any
from typing import Generic
from typing import TypeVar

from poetry.utils._compat import decode
from poetry.utils._compat import encode
from poetry.utils.wheel import InvalidWheelName
from poetry.utils.wheel import Wheel


if TYPE_CHECKING:
    from collections.abc import Callable
        expires = int(data_str[:10])
        return CacheItem(data, expires)


class ArtifactCache:
    # Cache instances are normally shared, but keeping the locks at class scope also
    # protects callers which construct more than one instance for the same cache.
    _link_locks: dict[Path, threading.Lock] = {}
    _link_locks_lock = threading.Lock()

    def __init__(self
…[2954 chars omitted]…
         )

    def get_cached_archive_for_git(
        self, url: str, reference: str, subdirectory: str | None, env: Env
    ) -> Path | None:
        cache_dir = self.get_cache_directory_for_git(url, reference, subdirectory)

        return self._get_cached_archive(cache_dir, strict=False, env=env)

    def _get_cached_archive(
        self,
        cache_dir: Path,
        *,
        strict: bool,

            try:
                original_archive = self._download_archive(operation, link)
            except BaseException:
                cache_directory = self._artifact_cache.get_cache_directory_for_link(
                    link
                )
                cached_file = cache_directory.joinpath(link.filename)
                c
…[1885 chars omitted]…
._enabled
        )

    def _save_url_reference(self, operation: Operation) -> None:
        """
        Create and store a PEP-610 `direct_url.json` file, if needed.
src/poetry/installation/executor.py:759:                original_archive = self._download_archive(operation, link)
src/poetry/installation/executor.py:818:    def _download_archive(self, operation: Install | Update, link: Link) -> Path:

        "demo",
        "0.1.2",
        source_type="directory",
        source_url=url.as_posix(),
        develop=True,
    )

    chef = Chef(artifact_cache, tmp_venv, Factory.create_pool(config))
    chef.set_directory_wheel(wheel)
    prepare_spy = mocker.spy(chef, "prepare")

    executor = Executor(tmp_venv, pool, config, io)
    executor._chef = chef
    executor.execute([Install(package)])
    verify_installed_distribution(
        tmp_venv, package, {"dir_info": {"editable": True}, "url":
…[2188 chars omitted]…
s://files.pythonhosted.org/demo-0.1.0.tar.gz",
    )
    # Set package.files so the executor will attempt to hash the package
    package.files = [
        {
            "file": "demo-0.1.0.tar.gz",
            "hash": "sha256:9fa123ad707a5c6c944743bf3e11a0e80d86cb518d3cf25320866ca3ef43e2ad",
        }
    ]

    executor = Executor(tmp_venv, pool, config, io)
18:from requests.utils import atomic_open

        """assert that the mock was called exactly once and that that call was
        with the specified arguments."""
        if not self.call_count ==
…[2982 chars omitted]…
n.py:54: AssertionError
=========================== short test summary info ============================
FAILED tests/packages/test_direct_origin.py::test_direct_origin_does_not_download_url_dependency_when_cached
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 26 passed in 4.59s

    from pathlib import Path

    from pytest_mock import MockerFixture

    from tests.types import FixtureDirGetter


def test_direct_origin_get_package_from_file(fixture_dir: FixtureDirGetter) -> None:
    wheel_path = fixture_dir("distributions") / "demo-0.1.2-py2.py3-none-any.whl"
    package = DirectOrigin.get_package_from_file(wheel_path)
    assert package.name == "demo"


def test_direct_origin_caches_url_dependency(tmp_path: Path) -> None:
    artifact_cache = ArtifactCache(cache_dir=tmp_path)
    direct_origin = DirectOrigin(artifact_cache)
    url = "https://python-poetry.org/distributions/demo-0.1.0-p
…[730 chars omitted]…
e_effect=Exception("download_file should not be called"),
    )

    package = direct_origin.get_package_from_url(url)

    assert package.name == "demo"
    artifact_cache.get_cached_archive_for_link.assert_called_once_with(
        Link(url), strict=True
    )
bringing up nodes...
bringing up nodes...

............................                                             [100%]
28 passed in 3.12s

fixture_dir = <function fixture_dir.<locals>._fixture_dir at 0x72c63a1096c0
…[8629 chars omitted]…
ck has completed successfully.
+                temporary.replace(destination)
+            finally:
+                temporary.unlink(missing_ok=True)
+
+            return self._get_cached_archive(
+                cache_dir, strict=strict, filename=link.filename, env=env
+            )
 
     def get_cached_archive_for_git(
         self, url: str, reference: str, subdirectory: str | None, env: Env

    
    """
    
        output = io.fetch_output()
>       assert output.startswith(expected_start)
E       AssertionError: assert False
E        +  where False = <built-in met
…[1439 chars omitted]…
correctly_if_caused_by_subprocess[False-exception1-build]
FAILED tests/installation/test_executor.py::test_build_backend_errors_are_reported_correctly_if_caused_by_subprocess[True-exception1-get_requires_for_build]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 6 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
6 failed, 1 passed in 5.10s

) -> None:
    fixture = fixture_dir("distributions") / "demo-0.1.0-py2.py3-none-any.whl"
    destination_fixture = tmp_path / "tomlkit-0.5.3-py2.py3-none-any.whl"
    shutil.copyfile(str(fixture), str(destination_fixture))
    mocker.patch(
        "poetry.installation.executor.Executor._download_archive",
        side_effect=Exception("Download error"),
    )
    mocker.patch(
        "poetry.installation.executor.ArtifactCache.get_cached_archive_for_link",
        return_value=None,
    )
    mocker.patch(
        "poetry.installation.executor.ArtifactCache.get_cache_directory_for_link
…[1084 chars omitted]…
    cached_file = cache_directory.joinpath(link.filename)
                cached_file.unlink(missing_ok=True)

                raise

        # Get potential higher prioritized cached archive, otherwise it will fall back
        # to the original archive.
        archive = self._artifact_cache.get_cached_archive_for_link(
            link,
            strict=False,
            env=self._env,
        )

package = Package('demo', '0.1.0', source_type='url', source_url='https://files.pythonhosted.org/demo-0.1.0.tar.gz')
url_reference = {'archive_info': {'hashes': {'sha256': '9fa123ad707a5c6c944743bf3e11a0e80d86cb518d3cf25320866ca3ef43e2ad'}}, 'url': 'https://files.pythonhosted.org/demo-0.1.0.tar.gz'}

    def verify_installed_distribution(
        venv: VirtualEnv, package: Package, url_reference
…[1764 chars omitted]…
ping after 4 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
4 failed, 2 passed in 5.22s
 src/poetry/installation/executor.py  | 25 ++++++++----------
 src/poetry/packages/direct_origin.py | 10 +++-----
 src/poetry/utils/cache.py            | 49 +++++++++++++++++++++++++++++++++---
 3 files changed, 61 insertions(+), 23 deletions(-)

-            # No cached original distributions was found, so we download and prepare it
-            try:
+        try:
+            original_archive = self._artifact_cache.get_cached_archive_for_link(
+                link,
+                strict=True,
+                download_func=lambda _url, destination: self._download_archive(
+              
…[2381 chars omitted]…
       link, strict=True, download_func=download_file
             )
-            artifact.parent.mkdir(parents=True, exist_ok=True)
-            download_file(url, artifact)
+        assert artifact is not None
 
         package = self.get_package_from_file(artifact)
         package.files = [
 M src/poetry/installation/executor.py
 M src/poetry/packages/direct_origin.py
 M src/poetry/utils/cache.py

src/poetry/console/commands/about.py
src/poetry/console/commands/add.py
src/poetry/console/commands/build.py
src/poetry/console/commands/cache/__init__.py
src/poetry/console/commands/cache/clear.py
src/poetry/console/commands/cache/list.py
src/poetry/console/commands/check.py
src/poetry/console/commands/command.py
src/poetry/console/commands/config.py
src/poetry/console/commands/debug/__init__.py
src/poetry/console/commands/debug/info.py
src/poetry/console/commands/debug/resolve.py
src/poetry/console
…[8629 chars omitted]…
/git/github.com/demo/demo/demo.egg-info/requires.txt
tests/fixtures/git/github.com/demo/demo/demo.egg-info/top_level.txt
tests/fixtures/git/github.com/demo/demo/demo/__init__.py
tests/fixtures/git/github.com/demo/demo/setup.py
tests/fixtures/git/github.com/demo/namespace-package-one/namespace_package/__init__.py
tests/fixtures/git/github.com/demo/namespace-package-one/namespace_package/one/__init__.py

from typing import Generic
from typing import TypeVar

from poetry.utils._compat import decode
from poetry.utils._compat import encode
from poetry.utils.wheel import InvalidWheelName
from poetry.utils.wheel import Wheel


if TYPE_CHECKING:
    from collections.abc import Callable

    from poetry.core.packages.utils.link import Link

    from poetry.utils.env import Env


# Used by FileCache for items that do not expire.
MAX_DATE = 9999999999
T = TypeVar("T")

logger = logging.getLogger(__name__)


def _expiration(minutes: int) -> int:
    """
    Calculates the time in seconds since epoch that occurs 'minutes' from now.

    :param minutes: The number of minutes to count forward
   
…[8630 chars omitted]…
poetry.org/distributions/demo-0.1.0-py2.py3-none-any.whl"
    mocker.patch(
        "poetry.packages.direct_origin.download_file",
        side_effect=Exception("download_file should not be called"),
    )

    package = direct_origin.get_package_from_url(url)

    assert package.name == "demo"
    artifact_cache.get_cached_archive_for_link.assert_called_once_with(
        Link(url), strict=True
    )

class ArtifactCache:
    def __init__(self, *, cache_dir: Path) -> None:
        self._cache_dir = cache_dir

    def get_cache_directory_for_link(self, link: Link) -> Path:
        key_parts = {"url": link.url_without_fragment}

        if link.hash_name is not None and link.hash is not None:
            key_parts[link.hash_name] = link.hash

        if link.subdirectory_fragment:
            key_parts["subdirectory"] = link.subdirectory_fragment

        return self._get_directory_
…[8264 chars omitted]…
kages/direct_origin.py:12:from poetry.utils.helpers import download_file
src/poetry/packages/direct_origin.py:86:            download_file(url, artifact)
src/poetry/repositories/http_repository.py:28:from poetry.utils.helpers import download_file
src/poetry/repositories/http_repository.py:78:        return download_file(url, dest, session=self.session)
src/poetry/utils/helpers.py:97:def download_file(

            # Store yanked warnings in a list and print after installing, so they can't
            # be overlooked. Further, printing them in the concerning section would have
            # the risk of overwriting the warning, so it is only briefly visible.
            message = (
                f"The file chosen for install of {operation.package.pretty_name} "
                f"{operation.package.pretty_version} ({link.show_url}) is yanked."
            )
            if link.yanked_reason:
                message +
…[4035 chars omitted]…
or.context() as update_context:
        update_context(f"Downloading {url}")

        if "Content-Length" in response.headers:
            try:
                total_size = int(response.headers["Content-Length"])
            except ValueError:
                total_size = 0

            fetched_size = 0
            last_percent = 0

            # if less than 1MB, we simply show that we're downloading

            archive = self._chef.prepare(archive, output_dir=output_dir)

        # Use the original archive to provide the correct hash.
        self._populate_hashes_dict(original_archive, package)

        return archive

    def _populate_hashes_dict(self, archive: Path, package: Package) -> None:
        if package.files and archive.name in {f["file"] for f in package.files}:
            archive_hash = self._validate_archive
…[2360 chars omitted]…
ry/utils/cache.py:221:    def get_cached_archive_for_link(
tests/packages/test_direct_origin.py:34:    assert artifact_cache.get_cached_archive_for_link(Link(url), strict=True)
tests/utils/test_cache.py:263:    archive = cache.get_cached_archive_for_link(Link(link), strict=strict, env=env)
tests/utils/test_cache.py:320:    archive = cache.get_cached_archive_for_link(Link(link), strict=strict, env=env)

actual = call(<Link https://python-poetry.org/distributions/demo-0.1.0-py2.py3-none-any.whl>, strict=True, download_func=<MagicMock name='download_file' id='135518154623984'>)
_error_message = <function NonCallableMock.assert_called_with.<locals>._error_m
…[4800 chars omitted]…
 more item:
E         {'download_func': <MagicMock name='download_file' id='135518154623984'>}
E         Use -v to get more diff

tests/packages/test_direct_origin.py:54: AssertionError
=========================== short test summary info ============================
FAILED tests/packages/test_direct_origin.py::test_direct_origin_does_not_download_url_dependency_when_cached
1 failed, 27 passed in 3.68s

            ),
        )
        if original_archive is None:
            # A non-archive link cannot be downloaded into the artifact cache.
            raise RuntimeError(f"Unable to download archive for {link.url}")

        # Get potential higher prioritized cached archive, otherwise it will fall back
        # to the origina
…[1668 chars omitted]…
" <b>%percent%%</b>")

        if progress:
            with self._lock:
                self._sections[id(operation)].clear()
                progress.start()

        done = 0
        archive = destination or (
            self._artifact_cache.get_cache_directory_for_link(link) / link.filename
        )
        archive.parent.mkdir(parents=True, exist_ok=True)
        with atomic_open(archive) as f:

tmp_path = PosixPath('/tmp/pytest-of-root/pytest-1/popen-gw1/test_execute_works_with_no_ans0')
mock_file_downloads = None
env = MockEnv("/tmp/pytest-of-root/pytest-1/popen-gw1/test_execute_works_with_no_ans0/.venv")

    def test_execute_works_with_no_ansi_output(
        mocker: MockerFixture,
        c
…[8630 chars omitted]…
kend_errors_are_reported_correctly_if_caused_by_subprocess[False-exception1-get_requires_for_build]
FAILED tests/installation/test_executor.py::test_executor_should_write_pep610_url_references_for_non_wheel_files
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 9 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 2 failures !!!!!!!!!!!!!
9 failed, 35 passed in 13.52s

                if progress:
                    with self._lock:
                        progress.set_progress(done)

                f.write(chunk)

        if progress:
            with self._lock:
                progress.finish()

        return archive

    def _should_write_operation(self, operation: Operation) -> bool:
        return (
            not operation.skipped or self._dry_run or self._verbose or not self._enabled
        )

    def _save_url_reference(self, operation: Oper
…[124 chars omitted]…
ration.job_type not in {"install", "update"}:
            return

        package = operation.package

        if not package.source_url or package.source_type == "legacy":
            # Since we are installing from our own distribution cache
            # pip will write a `direct_url.json` file pointing to the cache
18:from requests.utils import atomic_open
850:        with atomic_open(archive) as f:

+
+            return destination
+
+    @classmethod
+    def _get_archive_lock(cls, cache_dir: Path) -> threading.Lock:
+        with cls._archive_locks_lock:
+            return cls._archive_locks.setdefault(cache_dir, threading.Lock())
 
     def get_cached_archive_for_git(
         self, url: str, reference: str, subdirectory: str | None, env: Env

        "poetry.installation.executor.Executor._download_archive",
        side_effect=Exception("Download error"),
    )
    mocker.patch(
        "poetry.installation.executor.ArtifactCache.get_cached_archive_for_link",
        return_value=None,
    )
    mocker.patch(
        "poetry.installation.executor.ArtifactCache.get_cache_directory_for_link",
        return_value=tmp_path,
    )

    config.merge({"cache-dir": str(tmp_path)})

    executor = Executor(env, pool, c
…[321 chars omitted]…
tallation.executor.ArtifactCache.get_cached_archive_for_link",
829:    download_spy = mocker.spy(Executor, "_download_archive")
901:    download_spy = mocker.spy(Executor, "_download_archive")
907:        def mock_get_cached_archive_for_link_func(
917:            "poetry.installation.executor.ArtifactCache.get_cached_archive_for_link",
918:            side_effect=mock_get_cached_archive_for_link_func,

actual = call(<Link https://python-poetry.org/distributions/demo-0.1.0-py2.py3-none-any.whl>, strict=True, download_func=<MagicMock name='download_file' id='126413302454928'>)
_error_message = <function NonCallableMock.assert_called_with.<locals>._error_m
…[4984 chars omitted]…
r
=========================== short test summary info ============================
FAILED tests/packages/test_direct_origin.py::test_direct_origin_does_not_download_url_dependency_when_cached
1 failed, 27 passed in 4.57s
 src/poetry/packages/direct_origin.py | 11 ++------
 src/poetry/utils/cache.py            | 55 ++++++++++++++++++++++++++++++++++--
 2 files changed, 56 insertions(+), 10 deletions(-)

-
-        if not artifact:
-            artifact = (
-                self._artifact_cache.get_cache_directory_for_link(link) / link.filename
+        if artifact is None:
+            artifact = self._artifact_cache.get_cached_archive_for_link(
+                link, strict=True, download_f
…[3054 chars omitted]…
dir: Path) -> threading.Lock:
+        with cls._archive_locks_lock:
+            return cls._archive_locks.setdefault(cache_dir, threading.Lock())
 
     def get_cached_archive_for_git(
         self, url: str, reference: str, subdirectory: str | None, env: Env
bringing up nodes...
bringing up nodes...

............................                                             [100%]
28 passed in 3.75s

-rw-r--r-- 1 root root   1070 Oct  1 00:47 LICENSE
-rw-r--r-- 1 root root   4662 Oct  1 00:48 README.md
drwxr-xr-x 1 root root   4096 Oct  1 00:47 assets
drwxr-xr-x 1 root root   4096 Oct  1 00:48 docs
-rw-r--r-- 1 root root 129462 Oct  1 00:48 poetry.lock
-rw-r--r-- 1 root root   5251 Oct  1 00:48 pyproject.toml
drwxr-xr-x 1 root root   4096 Oct  1 00:47 src
drwxr-xr-x 1 root root   4096 Oct  1 00:48 tests
bash: line 6: rg: command not found

src/poetry/console/commands/about.py
src/poetry/console/commands/add.py
src/poetry/console/commands/build.py
src/poetry/console/commands/cache/__init__.py
src/poetry/console/commands/cache/clear.py
src/poetry/console/commands/cache/list.py
src/poetry/console/commands/check.py
src/poetry/console/commands/command.py
src/poetry/console/commands/config.py
src/poetry/console/commands/debug/__init__.py
src/poetry/console/commands/debug/info.py
src/poetry/console/commands/debug/resolve.py
src/poetry/console
…[8629 chars omitted]…
/git/github.com/demo/demo/demo.egg-info/requires.txt
tests/fixtures/git/github.com/demo/demo/demo.egg-info/top_level.txt
tests/fixtures/git/github.com/demo/demo/demo/__init__.py
tests/fixtures/git/github.com/demo/demo/setup.py
tests/fixtures/git/github.com/demo/namespace-package-one/namespace_package/__init__.py
tests/fixtures/git/github.com/demo/namespace-package-one/namespace_package/one/__init__.py

from typing import Generic
from typing import TypeVar

from poetry.utils._compat import decode
from poetry.utils._compat import encode
from poetry.utils.wheel import InvalidWheelName
from poetry.utils.wheel import Wheel


if TYPE_CHECKING:
    from collections.abc import Callable

    from poetry.core.packages.utils.link import Link

    from poetry.utils.env import Env


# Used by FileCache for items that do not expire.
MAX_DATE = 9999999999
T = TypeVar("T")

logger = logging.getLogger(__name__)


def _expiration(minutes: int) -> int:
    """
    Calculates the time in seconds since epoch that occurs 'minutes' from now.

    :param minutes: The number of minutes to count forward
   
…[8630 chars omitted]…
     ],
    )

    archive = cache.get_cached_archive_for_link(Link(link), strict=strict, env=env)

    assert Path(cached) == archive


def test_get_cached_archive_for_git() -> None:
    """Smoke test that checks that no assertion is raised."""
    cache = ArtifactCache(cache_dir=Path())
    archive = cache.get_cached_archive_for_git("url", "ref", "subdirectory", MockEnv())
    assert archive is None

        data = json.loads(data_str[10:])
        expires = int(data_str[:10])
        return CacheItem(data, expires)


class ArtifactCache:
    def __init__(self, *, cache_dir: Path) -> None:
        self._cache_dir = cache_dir

    def get_cache_directory_for_link(self, link: Link) -> Path:
        key_parts = {"url": link.url_without_fragment}

        if link.hash_name is not None
…[8628 chars omitted]…
ad_file(url, artifact)
src/poetry/repositories/http_repository.py:28:from poetry.utils.helpers import download_file
src/poetry/repositories/http_repository.py:78:        return download_file(url, dest, session=self.session)
src/poetry/repositories/pypi_repository.py:166:            self._log("No dependencies found, downloading archives", level="debug")
src/poetry/utils/helpers.py:97:def download_file(

        wheel_size = response.headers.get("content-length")
        operation_message = self.get_operation_message(operation)
        message = (
            f"  <fg=blue;options=bold>•</> {operation_message}: <info>Downloading...</>"
        )
        progress = None
        if self.supports_fancy_output():
            if wheel_size is None:
                self._write(operation, message)
            else:
  
…[7269 chars omitted]…
load_archive",
tests/installation/test_executor.py:829:    download_spy = mocker.spy(Executor, "_download_archive")
tests/installation/test_executor.py:901:    download_spy = mocker.spy(Executor, "_download_archive")
tests/packages/test_direct_origin.py:31:    package = direct_origin.get_package_from_url(url)
tests/packages/test_direct_origin.py:51:    package = direct_origin.get_package_from_url(url)

    mock_file_downloads: None,
    env: MockEnv,
    fixture_dir: FixtureDirGetter,
) -> None:
    fixture = fixture_dir("distributions") / "demo-0.1.0-py2.py3-none-any.whl"
    destination_fixture = tmp_path / "tomlkit-0.5.3-py2.py3-none-any.whl"
    shutil.copyfile(str(fixture), str(destination_fixture))
    mocker.patch(
        "poetry.installation.executor.Executor._download_archive",
        side_effect=Exception("Download error"),
    )
    mocker.patch(
        "poetry.installation.executor.ArtifactCache.get_cached_archive_for_link",
        return_value=None,
    )
    mocker.patch(
        "poetry.installation.executor.ArtifactCache.ge
…[5626 chars omitted]…
t_package_from_url(url)

    assert package.name == "demo"
    artifact_cache.get_cached_archive_for_link.assert_called_once_with(
        Link(url), strict=True
    )
src/poetry/installation/executor.py:759:                original_archive = self._download_archive(operation, link)
src/poetry/installation/executor.py:818:    def _download_archive(self, operation: Install | Update, link: Link) -> Path:

    def get_cached_archive_for_link(
        self,
        link: Link,
        *,
        strict: bool,
        env: Env | None = None,
        download_func: Callable[[str, Path], None] | None = None,
    ) -> Path | None:
        cache_dir = self.get_cache_directory_for_link(link)
        cached = self._get_cached_archive(
            cache_dir, strict=strict, filename=link.filename, env=env
        )
        if cached is not None or download_func is None:
            return cached

  
…[2552 chars omitted]…
_for_link(
            link, strict=True, download_func=download_file
        )

        assert artifact is not None

        package = self.get_package_from_file(artifact)
        package.files = [
            {"file": link.filename, "hash": "sha256:" + get_file_hash(artifact)}
        ]

        package._source_type = "url"
        package._source_url = url

        return package

    @staticmethod

/usr/local/lib/python3.12/unittest/mock.py:949: in assert_called_with
    raise AssertionError(_error_message()) from cause
E   AssertionError: expected call not found.
E   Expected: get_cached_archive_for_link(<Link https://python-poetry.org/distributions/demo-0.1.0-py2.py3-none-any.whl>, strict=True)
E     Actual: get_cached_archive_for_link(<Link https://python-poetry.org/distributions/demo-0.1.0-py2.py3-none-any.whl>, strict=True, download_func=<MagicMock name='download_file' id='128611794722000'>)

During handling of the above exceptio
…[1771 chars omitted]…
Use -v to get more diff
=========================== short test summary info ============================
FAILED tests/packages/test_direct_origin.py::test_direct_origin_does_not_download_url_dependency_when_cached
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 26 passed in 4.30s

E     
E       • Updating black (19.10b0 -> 21.11b0)
E       • Updating pytest (3.5.0 -> 3.5.1)
E     
E       UnmockedError
E     
E       Failed to socket.shutdown because because a real socket does not exist
E       
E       Tip: You could try setting (allow_net_connect=True) to allow unregistered requests through a real TCP connection in a
…[7277 chars omitted]…
used_by_subprocess[False-exception1-get_requires_for_build]
FAILED tests/installation/test_executor.py::test_build_backend_errors_are_reported_correctly_if_caused_by_subprocess_encoding[Err\xf6r on stderr-latin-1]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 5 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
5 failed, 33 passed in 5.23s

+++ b/src/poetry/installation/executor.py
@@ -751,20 +751,16 @@ class Executor:
         output_dir = self._artifact_cache.get_cache_directory_for_link(link)
         # Try to get cached original package for the link provided
         original_archive = self._artifact_cache.get_cached_archive_for_link(
-            link, strict=True
+            link
…[6029 chars omitted]…
rchive_types = ["whl", "tar.gz", "tar.bz2", "bz2", "zip"]
         paths: list[Path] = []
         for archive_type in archive_types:
-            paths += cache_dir.glob(f"*.{archive_type}")
+            paths += [
+                path
+                for path in cache_dir.glob(f"*.{archive_type}")
+                if path.is_file() and path.stat().st_size > 0
+            ]
 
         return paths

During handling of the above exception, another exc
…[1772 chars omitted]…
ore diff
=========================== short test summary info ============================
FAILED tests/packages/test_direct_origin.py::test_direct_origin_does_not_download_url_dependency_when_cached
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 failed, 28 passed in 4.71s
1 1 b'archive'

bash: line 6: rg: command not found

src/poetry/console/commands/new.py
src/poetry/console/commands/publish.py
src/poetry/console/commands/remove.py
src/poetry/console/commands/run.py
src/poetry/console/commands/search.py
src/poetry/console/commands/self/add.py
src/poetry/console/commands/self/install.py
src/poetry/console/commands/self/lock.py
src/poetry/console/commands/self/remove.py

from typing import Generic
from typing import TypeVar

from poetry.utils._compat import decode
from poetry.utils._compat import encode
from poetry.utils.wheel import InvalidWheelName
from poetry.utils.wheel import Wheel


if TYPE_CHECKING:
    from collections.abc import Callable

    from poetry.core.packages.utils.link import Link

    from poetry.utils.env import Env


# Used by FileCache for items that do not expire.
MAX_DATE = 9999999999
T = TypeVar("T")

logger = logging.getLogger(__name__)


def _expiration(minutes: int) -> int:
    """
    Calculates the time in seconds since epoch that occurs 'minutes' from now.

    :param minutes: The number of minutes to count forward
   
…[8630 chars omitted]…
     ],
    )

    archive = cache.get_cached_archive_for_link(Link(link), strict=strict, env=env)

    assert Path(cached) == archive


def test_get_cached_archive_for_git() -> None:
    """Smoke test that checks that no assertion is raised."""
    cache = ArtifactCache(cache_dir=Path())
    archive = cache.get_cached_archive_for_git("url", "ref", "subdirectory", MockEnv())
    assert archive is None

    def get_cache_directory_for_link(self, link: Link) -> Path:
        key_parts = {"url": link.url_without_fragment}

        if link.hash_name is not None and link.hash is not None:
            key_parts[link.hash_name] = link.hash

        if link.subdirectory_fragment:
            key_parts["subdirectory"] = link.subdirectory_fragment

        return self._get_directory_from_hash(key_parts)

    def _get_directory_from_hash(self, key_parts: object) -> Path:
        key = hashlib.sha256(
            json.dumps(
                key_part
…[8010 chars omitted]…
               )

            destination.mkdir(parents=True, exist_ok=True)

            return self._prepare(
                sdist_dir,
                destination,
            )

    def _should_prepare(self, archive: Path) -> bool:
        return archive.is_dir() or not self._is_wheel(archive)

    @classmethod
    def _is_wheel(cls, archive: Path) -> bool:
        return archive.suffix == ".whl"

from poetry.utils.helpers import download_file
from poetry.utils.helpers import get_file_hash
from poetry.vcs.git import Git


if TYPE_CHECKING:
    from poetry.core.packages.package import Package

    from poetry.utils.cache import ArtifactCache


@functools.lru_cache(maxsize=None)
def _get_package_from_git(
    url: str,
    branch: str | None = None,
    tag: str | None = None,
    rev: str | None = None,
    subdirectory: str | None = None,
    source_root: Path | None = None,
) -> Package:
    source =
…[515 chars omitted]…
poetry/packages/direct_origin.py:79:        artifact = self._artifact_cache.get_cached_archive_for_link(link, strict=True)
src/poetry/utils/cache.py:221:    def get_cached_archive_for_link(
[tool.poetry.dependencies]
python = "^3.8"

poetry-core = "1.7.0"
poetry-plugin-export = "^1.5.0"
build = "^1.0.3"
cachecontrol = { version = "^0.13.0", extras = ["filecache"] }
cleo = "^2.0.0"
crashtest = "^0.4.1"

        wheel_size = response.headers.get("content-length")
        operation_message = self.get_operation_message(operation)
        message = (
            f"  <fg=blue;options=bold>•</> {operation_message}: <info>Downloading...</>"
        )
        progress = None
        if self.supports_fancy_output():
            if wheel_size is None:
                self._write(operation, message)
            else:
  
…[1892 chars omitted]…
 = DirectOrigin(artifact_cache)
tests/packages/test_direct_origin.py:8:from poetry.packages.direct_origin import DirectOrigin
tests/packages/test_direct_origin.py:22:    package = DirectOrigin.get_package_from_file(wheel_path)
tests/packages/test_direct_origin.py:28:    direct_origin = DirectOrigin(artifact_cache)
tests/packages/test_direct_origin.py:44:    direct_origin = DirectOrigin(artifact_cache)

    def _save_url_reference(self, operation: Operation) -> None:
        """
        Create and store a PEP-610 `direct_url.json` file, if needed.
        """
        if operation.job_type not in {"install", "update"}:
            return

        package = operation.package

        if not package.source_url or package.source_type == "legacy":
            # Since we are installing from our own distribution cache
            # pip will write a `direct_url.json` file pointing to the cache
            # distribution.
            # That's not what we want, so we remov
…[3513 chars omitted]…
poetry.org/distributions/demo-0.1.0-py2.py3-none-any.whl"
    mocker.patch(
        "poetry.packages.direct_origin.download_file",
        side_effect=Exception("download_file should not be called"),
    )

    package = direct_origin.get_package_from_url(url)

    assert package.name == "demo"
    artifact_cache.get_cached_archive_for_link.assert_called_once_with(
        Link(url), strict=True
    )

32-
33-    from poetry.utils.authenticator import Authenticator
34-
35-
36-@contextmanager
37-def directory(path: Path) -> Iterator[Path]:
38-    cwd = Path.cwd()
39-    try:
40-        os.chdir(path)

-            link, strict=True
+            link,
+            strict=True,
+            download_func=lambda url, destination: self._download_archive(
+                operation, link
+   
…[4089 chars omitted]…
ached_archive(
+                cache_dir, strict=strict, filename=link.filename, env=env
+            )
+
+    @classmethod
+    def _get_link_lock(cls, key: Path) -> threading.Lock:
+        with cls._link_locks_lock:
+            return cls._link_locks.setdefault(key, threading.Lock())
 
     def get_cached_archive_for_git(
         self, url: str, reference: str, subdirectory: str | None, env: Env

        mocker.patch.object(ProjectBuilder, failing_method, side_effect=error)
        io.set_verbosity(Verbosity.NORMAL)
    
        executor = Executor(env, pool, config, io)
    
        package_name = "simple-project"
        package_version = "1.2.3"
        directory_package = Package(
            package_name,
            package_version,
            source_type="directory",
            source_url=fixture_dir("simple_project").resolve().as_posix(),
            develop=editable,
        )
     
…[3017 chars omitted]…
n/test_executor.py::test_build_backend_errors_are_reported_correctly_if_caused_by_subprocess[True-exception0-build]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 6 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!! xdist.dsession.Interrupted: stopping after 1 failures !!!!!!!!!!!!!
1 8 {PosixPath('/tmp/tmpqei6ma3w/c4/86/8c/ab730f9548f58d58a562cceece80d12166c0f179988220419790f03961/foo-1.0.tar.gz')} b'good'

        mock_file_downloads: None,
        env: MockEnv,
        fixture_dir: FixtureDirGetter,
    ) -> None:
        fixture = fixture_dir("distributions") / "demo-0.1.0-py2.py3-none-any.whl"
        destination_fixture = tmp_path / "tomlkit-0.5.3-py2.py3-none-any.whl"
        shutil.copyfile(str(fixture), str(destination_fixture))
        mocker.pa
…[7373 chars omitted]…
ached_archive(
+                cache_dir, strict=strict, filename=link.filename, env=env
+            )
+
+    @classmethod
+    def _get_link_lock(cls, key: Path) -> threading.Lock:
+        with cls._link_locks_lock:
+            return cls._link_locks.setdefault(key, threading.Lock())
 
     def get_cached_archive_for_git(
         self, url: str, reference: str, subdirectory: str | None, env: Env

        message = (
            f"  <fg=blue;options=bold>•</> {operation_message}: <info>Downloading...</>"
        )
        progress = None
        if self.supports_fancy_output():
            if wheel_size is None:
                self._write(operation, message)
            else:
                from cleo.ui.progress_bar import ProgressBar

                progress = ProgressBar(
                    self._sections[id(operation)], max=int(wheel
…[3052 chars omitted]…
        cache_dir = self.get_cache_directory_for_git(url, reference, subdirectory)

        return self._get_cached_archive(cache_dir, strict=False, env=env)

    def _get_cached_archive(
        self,
        cache_dir: Path,
        *,
        strict: bool,
        filename: str | None = None,
 M src/poetry/installation/executor.py
 M src/poetry/packages/direct_origin.py
 M src/poetry/utils/cache.py

/repo/src/poetry/installation/executor.py:771:        archive = self._artifact_cache.get_cached_archive_for_link(
/repo/src/poetry/packages/direct_origin.py:79:        artifact = self._artifact_cache.get_cached_archive_for_link(link, strict=True)
/repo/src/poetry/utils/cache.py:221:    def get_cached_archive_for_link(

        key_parts = {"url": link.url_without_fragment}

        if link.hash_name is not None and link.hash is not None:
            key_parts[link.hash_name] = link.hash

        if link.subdirectory_fragment:
            key_parts["subdirectory"] = link.subdirectory_fragment

        return self._get_directory_from_hash(key_parts)

    def _get_directory_from_hash(self, key_parts: object) -> Path:
        key = hashlib.sha256(
            json.dumps(
                key_parts, sort_keys=True, separa
…[4247 chars omitted]…
       subdirectory: str | None = None,
        source_root: Path | None = None,
    ) -> Package:
        if vcs != "git":
            raise ValueError(f"Unsupported VCS dependency {vcs}")

        return _get_package_from_git(
            url=url,
            branch=branch,
            tag=tag,
            rev=rev,
            subdirectory=subdirectory,
            source_root=source_root,
        )

test_dependency_specification.py
test_env.py
test_env_site.py
test_extras.py
test_helpers.py
test_password_manager.py
test_patterns.py
test_pip.py
test_setup_reader.py
test_source.py

190:def test_get_cache_directory_for_git(tmp_path: Path, subdirectory: str | None) -> None:
210:def test_get_cached_archives(f
…[1675 chars omitted]…
poetry.org/distributions/demo-0.1.0-py2.py3-none-any.whl"
    mocker.patch(
        "poetry.packages.direct_origin.download_file",
        side_effect=Exception("download_file should not be called"),
    )

    package = direct_origin.get_package_from_url(url)

    assert package.name == "demo"
    artifact_cache.get_cached_archive_for_link.assert_called_once_with(
        Link(url), strict=True
    )

        # Try to get cached original package for the link provided
        original_archive = self._artifact_cache.get_cached_archive_for_link(
            link, strict=True
        )
        if original_archive is None:
            # No cached original distributions was found, so we download and prepare it
            try:
                original_archive = self._download_archive(operati
…[1921 chars omitted]…
ge_from_git(
    url: str,
    branch: str | None = None,
    tag: str | None = None,
    rev: str | None = None,
    subdirectory: str | None = None,
    source_root: Path | None = None,
) -> Package:
    source = Git.clone(
        url=url,
        source_root=source_root,
        branch=branch,
        tag=tag,
        revision=rev,
        clean=False,
    )
    revision = Git.get_revision(source)

from typing import Generic
from typing import TypeVar

from poetry.utils._compat import decode
from poetry.utils._compat import encode
from poetry.utils.wheel import InvalidWheelName
from poetry.utils.wheel import Wheel


if TYPE_CHECKING:
    from collections.abc import Callable

    from poetry.core.packages.utils.link import Link

    from poetry.utils.env import Env


# Used by FileCache for items that do not expire.

        package.files = [
            {"file": link.filename, "hash": "sha256:" + get_file_hash(artifact)}
        ]

        package._source_type = "url"
        package._source_url = url

        return package

=========================== short test summary info ============================
FAILED tests/packages/test_direct_origin.py::test_direct_origin_does_not_download_url_dependency_when_cached
1 failed, 27 passed in 4.39s