Mostly performance minded but does fix a bug upgrading packages with markers on CLI

Author: matteius

pipenv/project.py

@@ -69,6 +69,7 @@
     system_which,
 )
 from pipenv.utils.toml import cleanup_toml, convert_toml_outline_tables
+from pipenv.vendor.tomlkit.toml_document import TOMLDocument
 from pipenv.vendor import plette, tomlkit
 
 try:
@@ -138,6 +139,53 @@ class SourceNotFound(KeyError):
     pass
 
 
+class PipfileReader:
+    _instance = None
+    _instances = {}  # path -> instance mapping
+
+    def __new__(cls, pipfile_path: str | Path):
+        path_key = str(Path(pipfile_path).resolve())
+        if path_key not in cls._instances:
+            cls._instances[path_key] = super().__new__(cls)
+        return cls._instances[path_key]
+
+    def __init__(self, pipfile_path: str | Path):
+        # Only initialize if this is a new instance
+        if not hasattr(self, "pipfile_path"):  # Check if already initialized
+            self.pipfile_path = Path(pipfile_path)
+            self._cached_mtime = None
+            self._cached_content = None
+
+    def _is_cache_valid(self) -> bool:
+        """Check if the cached content is still valid based on mtime"""
+        if self._cached_mtime is None or self._cached_content is None:
+            return False
+
+        current_mtime = os.path.getmtime(self.pipfile_path)
+        return current_mtime == self._cached_mtime
+
+    def read_pipfile(self) -> str:
+        """Read the raw contents of the Pipfile"""
+        return self.pipfile_path.read_text()
+
+    def _parse_pipfile(self, contents: str) -> TOMLDocument | TPipfile:
+        """Parse the TOML contents"""
+        return tomlkit.parse(contents)
+
+    @property
+    def parsed_pipfile(self) -> TOMLDocument | TPipfile:
+        """Parse Pipfile into a TOMLFile with caching based on mtime"""
+        if self._is_cache_valid():
+            return self._cached_content
+
+        # Cache is invalid or doesn't exist, reload the file
+        contents = self.read_pipfile()
+        self._cached_content = self._parse_pipfile(contents)
+        self._cached_mtime = os.path.getmtime(self.pipfile_path)
+
+        return self._cached_content
+
+
 class Project:
     """docstring for Project"""
 
@@ -208,6 +256,8 @@ def __init__(self, python_version=None, chdir=True):
             default_sources_toml += f"\n\n[[source]]\n{tomlkit.dumps(pip_conf_index)}"
         plette.pipfiles.DEFAULT_SOURCE_TOML = default_sources_toml
 
+        self._pipfile_reader = PipfileReader(self.pipfile_location)
+
         # Hack to skip this during pipenv run, or -r.
         if ("run" not in sys.argv) and chdir:
             with contextlib.suppress(TypeError, AttributeError):
@@ -666,49 +716,7 @@ def requirements_location(self) -> str | None:
     @property
     def parsed_pipfile(self) -> tomlkit.toml_document.TOMLDocument | TPipfile:
         """Parse Pipfile into a TOMLFile"""
-        contents = self.read_pipfile()
-        return self._parse_pipfile(contents)
-
-    def read_pipfile(self) -> str:
-        # Open the pipfile, read it into memory.
-        if not self.pipfile_exists:
-            return ""
-        with open(self.pipfile_location) as f:
-            contents = f.read()
-            self._pipfile_newlines = preferred_newlines(f)
-
-        return contents
-
-    def _parse_pipfile(
-        self, contents: str
-    ) -> tomlkit.toml_document.TOMLDocument | TPipfile:
-        try:
-            return tomlkit.parse(contents)
-        except Exception:
-            # We lose comments here, but it's for the best.)
-            # Fallback to toml parser, for large files.
-            return toml.loads(contents)
-
-    def _read_pyproject(self) -> None:
-        pyproject = self.path_to("pyproject.toml")
-        if os.path.exists(pyproject):
-            self._pyproject = toml.load(pyproject)
-            build_system = self._pyproject.get("build-system", None)
-            if not os.path.exists(self.path_to("setup.py")):
-                if not build_system or not build_system.get("requires"):
-                    build_system = {
-                        "requires": ["setuptools>=40.8.0", "wheel"],
-                        "build-backend": get_default_pyproject_backend(),
-                    }
-                self._build_system = build_system
-
-    @property
-    def build_requires(self) -> list[str]:
-        return self._build_system.get("requires", ["setuptools>=40.8.0", "wheel"])
-
-    @property
-    def build_backend(self) -> str:
-        return self._build_system.get("build-backend", get_default_pyproject_backend())
+        return self._pipfile_reader.parsed_pipfile
 
     @property
     def settings(self) -> tomlkit.items.Table | dict[str, str | bool]:
@@ -828,8 +836,7 @@ def dev_packages(self):
     def pipfile_is_empty(self):
         if not self.pipfile_exists:
             return True
-
-        if not self.read_pipfile():
+        if not self.pipfile_exists:
             return True
 
         return False

pipenv/routines/update.py

@@ -290,8 +290,13 @@ def upgrade(
     # Early conflict detection
     conflicts_found = False
     for package in package_args:
-        if "==" in package:
-            name, version = package.split("==")
+        package_parts = [package]
+        if ";" in package:
+            package_parts = package.split(";")
+            # Not using markers here for now
+            # markers = ";".join(package_parts[1:]) if len(package_parts) > 1 else None
+        if "==" in package_parts[0]:
+            name, version = package_parts[0].split("==")
             conflicts = check_version_conflicts(name, version, reverse_deps, lockfile)
             if conflicts:
                 conflicts_found = True

pipenv/utils/developers.py

@@ -0,0 +1,61 @@
+import cProfile
+import functools
+import os
+import pstats
+from datetime import datetime
+from pstats import SortKey
+
+
+def profile_method(output_dir="profiles"):
+    """
+    Decorator to profile pipenv method execution with focus on file reads.
+    """
+
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            os.makedirs(output_dir, exist_ok=True)
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            profile_name = f"{func.__name__}_{timestamp}"
+            profile_path = os.path.join(output_dir, f"{profile_name}.prof")
+
+            profiler = cProfile.Profile()
+            profiler.enable()
+
+            try:
+                result = func(*args, **kwargs)
+                return result
+            finally:
+                profiler.disable()
+
+                # Save and analyze stats
+                stats = pstats.Stats(profiler)
+                stats.sort_stats(SortKey.CUMULATIVE)
+                stats.dump_stats(profile_path)
+                print(f"\nProfile saved to: {profile_path}")
+
+                # Analyze file reads specifically
+                print("\nAnalyzing file read operations:")
+                print("-" * 50)
+
+                # Get all entries involving file read operations
+                read_stats = stats.stats
+                for (file, line, name), (_, _, tt, _, callers) in read_stats.items():
+                    if "read" in str(name):
+                        # Print the call stack for this read operation
+                        print(f"\nFile read at: {file}:{line}")
+                        print(f"Function: {name}")
+                        print(f"Time: {tt:.6f}s")
+                        print("Called by:")
+                        for caller in callers:
+                            caller_file, caller_line, caller_name = caller
+                            print(f"  {caller_name} in {caller_file}:{caller_line}")
+                        print("-" * 30)
+
+                # Print overall stats
+                print("\nTop 20 overall calls:")
+                stats.print_stats(20)
+
+        return wrapper
+
+    return decorator