fix lint

Author: matteius

pipenv/cli/options.py

@@ -3,6 +3,7 @@
 
 from pipenv.project import Project
 from pipenv.utils import console, err
+from pipenv.utils.display import format_help
 from pipenv.utils.internet import is_valid_url
 from pipenv.vendor.click import (
     BadArgumentUsage,
@@ -23,8 +24,6 @@ class PipenvGroup(DYMMixin, Group):
     """Custom Group class provides formatted main help"""
 
     def get_help_option(self, ctx):
-        from pipenv.utils.display import format_help
-
         """Override for showing formatted main help via --help and -h options"""
         help_options = self.get_help_option_names(ctx)
         if not help_options or not self.add_help_option:

pipenv/environment.py

@@ -8,6 +8,7 @@
 import sys
 import typing
 from functools import cached_property
+from itertools import chain
 from pathlib import Path
 from sysconfig import get_paths, get_python_version, get_scheme_names
 from urllib.parse import urlparse
@@ -16,6 +17,7 @@
 from pipenv.patched.pip._internal.commands.install import InstallCommand
 from pipenv.patched.pip._internal.index.package_finder import PackageFinder
 from pipenv.patched.pip._internal.req.req_install import InstallRequirement
+from pipenv.patched.pip._vendor.packaging.markers import UndefinedEnvironmentName
 from pipenv.patched.pip._vendor.packaging.specifiers import SpecifierSet
 from pipenv.patched.pip._vendor.packaging.utils import canonicalize_name
 from pipenv.patched.pip._vendor.packaging.version import parse as parse_version
@@ -25,9 +27,12 @@
 from pipenv.utils.funktools import chunked, unnest
 from pipenv.utils.indexes import prepare_pip_source_args
 from pipenv.utils.processes import subprocess_run
+from pipenv.utils.resolver import get_package_finder
 from pipenv.utils.shell import temp_environ
 from pipenv.utils.virtualenv import virtualenv_scripts_dir
 from pipenv.vendor.importlib_metadata.compat.py39 import normalized_name
+from pipenv.vendor.pipdeptree._models.dag import PackageDAG
+from pipenv.vendor.pipdeptree._models.package import InvalidRequirementError
 from pipenv.vendor.pythonfinder.utils import is_in_path
 
 if sys.version_info < (3, 10):
@@ -262,8 +267,6 @@ def sys_path(self) -> list[str]:
         :return: The :data:`sys.path` from the environment
         :rtype: list
         """
-        import json
-
         current_executable = Path(sys.executable).as_posix()
         if not self.python or self.python == current_executable:
             return sys.path
@@ -551,8 +554,6 @@ def get_installed_packages(self) -> list[importlib_metadata.Distribution]:
 
     @contextlib.contextmanager
     def get_finder(self, pre: bool = False) -> ContextManager[PackageFinder]:
-        from .utils.resolver import get_package_finder
-
         pip_command = InstallCommand(
             name="InstallCommand", summary="pip Install command."
         )
@@ -633,11 +634,6 @@ def _get_requirements_for_package(cls, node, key_tree, parent=None, chain=None):
         return d
 
     def get_package_requirements(self, pkg=None):
-        from itertools import chain
-
-        from pipenv.patched.pip._vendor.packaging.markers import UndefinedEnvironmentName
-        from pipenv.vendor.pipdeptree._models.dag import PackageDAG
-        from pipenv.vendor.pipdeptree._models.package import InvalidRequirementError
 
         flatten = chain.from_iterable
 

pipenv/utils/resolver.py

@@ -1,9 +1,11 @@
 import contextlib
+import hashlib
 import json
 import os
 import subprocess
 import sys
 import tempfile
+import time
 import warnings
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -707,6 +709,73 @@ def clean_results(self) -> List[Dict[str, Any]]:
         return list(results.values())
 
 
+# Global cache for resolution results to avoid repeated expensive subprocess calls
+_resolution_cache = {}
+_resolution_cache_timestamp = {}
+
+
+def _generate_resolution_cache_key(
+    deps, project, pipfile_category, pre, clear, allow_global, pypi_mirror, extra_pip_args
+):
+    """Generate a cache key for resolution results."""
+    # Get lockfile and pipfile modification times
+    lockfile_mtime = "no-lock"
+    if project.lockfile_location:
+        lockfile_path = Path(project.lockfile_location)
+        if lockfile_path.exists():
+            lockfile_mtime = str(lockfile_path.stat().st_mtime)
+
+    pipfile_mtime = "no-pipfile"
+    if project.pipfile_location:
+        pipfile_path = Path(project.pipfile_location)
+        if pipfile_path.exists():
+            pipfile_mtime = str(pipfile_path.stat().st_mtime)
+
+    # Include environment variables that affect resolution
+    env_factors = [
+        os.environ.get("PIPENV_CACHE_VERSION", "1"),
+        os.environ.get("PIPENV_PYPI_MIRROR", ""),
+        os.environ.get("PIP_INDEX_URL", ""),
+        str(pypi_mirror) if pypi_mirror else "",
+        json.dumps(extra_pip_args, sort_keys=True) if extra_pip_args else "",
+    ]
+
+    # Create a deterministic representation of dependencies
+    deps_str = json.dumps(deps, sort_keys=True) if isinstance(deps, dict) else str(deps)
+
+    key_components = [
+        str(project.project_directory),
+        lockfile_mtime,
+        pipfile_mtime,
+        deps_str,
+        str(pipfile_category),
+        str(pre),
+        str(clear),
+        str(allow_global),
+        "|".join(env_factors),
+    ]
+
+    key_string = "|".join(key_components)
+    return hashlib.md5(key_string.encode()).hexdigest()
+
+
+def _should_use_resolution_cache(cache_key, clear):
+    """Check if we should use cached resolution results."""
+    if clear:
+        return False
+
+    if cache_key not in _resolution_cache:
+        return False
+
+    if cache_key not in _resolution_cache_timestamp:
+        return False
+
+    # Cache is valid for 10 minutes
+    current_time = time.time()
+    cache_age = current_time - _resolution_cache_timestamp[cache_key]
+    return cache_age < 600  # 10 minutes
+
+
 def _show_warning(message, category, filename, lineno, line):
     warnings.showwarning(
         message=message,
@@ -835,6 +904,31 @@ def venv_resolve_deps(
         lockfile = project.lockfile(categories=[pipfile_category])
     if old_lock_data is None:
         old_lock_data = lockfile.get(lockfile_category, {})
+
+    # Check cache before expensive resolution
+    cache_key = _generate_resolution_cache_key(
+        deps,
+        project,
+        pipfile_category,
+        pre,
+        clear,
+        allow_global,
+        pypi_mirror,
+        extra_pip_args,
+    )
+
+    if _should_use_resolution_cache(cache_key, clear):
+        if project.s.is_verbose():
+            err.print("[dim]Using cached resolution results...[/dim]")
+        cached_results = _resolution_cache[cache_key]
+        return prepare_lockfile(
+            project,
+            cached_results,
+            pipfile,
+            lockfile.get(lockfile_category, {}),
+            old_lock_data,
+        )
+
     req_dir = create_tracked_tempdir(prefix="pipenv", suffix="requirements")
     results = []
     with temp_environ():
@@ -939,6 +1033,21 @@ def venv_resolve_deps(
                     )
                     err.print(f"Output: {c.stdout.strip()}")
                     err.print(f"Error: {c.stderr.strip()}")
+
+    # Cache the results for future use
+    if results:
+        _resolution_cache[cache_key] = results
+        _resolution_cache_timestamp[cache_key] = time.time()
+
+        # Clean old cache entries (keep only last 5 projects)
+        if len(_resolution_cache) > 5:
+            oldest_key = min(
+                _resolution_cache_timestamp.keys(),
+                key=lambda k: _resolution_cache_timestamp[k],
+            )
+            _resolution_cache.pop(oldest_key, None)
+            _resolution_cache_timestamp.pop(oldest_key, None)
+
     if lockfile_category not in lockfile:
         lockfile[lockfile_category] = {}
     return prepare_lockfile(