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/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
@@ -24,7 +26,6 @@
 from pipenv.patched.pip._internal.req.req_install import InstallRequirement
 from pipenv.patched.pip._internal.utils.temp_dir import global_tempdir_manager
 from pipenv.patched.pip._vendor.packaging.utils import canonicalize_name
-from pipenv.project import Project
 from pipenv.utils import console, err
 from pipenv.utils.dependencies import determine_vcs_revision_hash, normalize_vcs_url
 from pipenv.utils.fileutils import create_tracked_tempdir
@@ -166,7 +167,7 @@ def check_if_package_req_skipped(
     def create(
         cls,
         deps: Dict[str, str],
-        project: Project,
+        project,
         index_lookup: Dict[str, str] = None,
         markers_lookup: Dict[str, str] = None,
         sources: List[str] = None,
@@ -707,6 +708,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 +903,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 +1032,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(