⚡ perf(link): skip fragment regex when fragment marker absent

Every `Link` runs `_egg_fragment_re.search` and `_subdirectory_fragment_re.search`
against `self._url` to find the matching fragment, even though Warehouse-served
URLs (the bulk of links a Simple-API response carries) never include either
fragment. Each regex search compiles a Boyer-Moore state and walks the full URL,
which adds up across the ~65000 links a moderately sized cross-platform lock
iterates per resolver pass.

Guard each search with a literal `"egg=" not in self._url` (resp. `"subdirectory="
not in self._url`) pre-check. Python's substring search is C-implemented and
runs an order of magnitude faster than the regex when the marker is absent;
when the marker is present the existing regex still runs, so behaviour is
preserved for VCS / direct-URL / `find-links` style URLs that carry it.

A new `test_fragments_absent_for_typical_links` parametrize asserts both
accessors return `None` for a representative spread of Simple-API URLs. The
existing `test_fragments` and `test_invalid_egg_fragments` cases all carry
explicit `#egg=…` / `&subdirectory=…` fragments and continue to exercise the
slow path.

Author: gaborbernat

news/13987.feature.rst

@@ -0,0 +1,4 @@
+Speed up ``Link`` construction by skipping the ``egg=`` and
+``subdirectory=`` fragment regex searches when the corresponding marker is
+absent from the URL, which is the common case for links returned by the
+Simple-API JSON response.

src/pip/_internal/models/link.py

@@ -475,6 +475,11 @@ def url_without_fragment(self) -> str:
     )
 
     def _egg_fragment(self) -> str | None:
+        # Cheap pre-check: the regex below cannot match unless ``egg=`` appears
+        # somewhere in the URL, which it never does for the bulk of links a
+        # Simple-API response carries.
+        if "egg=" not in self._url:
+            return None
         match = self._egg_fragment_re.search(self._url)
         if not match:
             return None
@@ -491,6 +496,9 @@ def _egg_fragment(self) -> str | None:
 
     @property
     def subdirectory_fragment(self) -> str | None:
+        # Cheap pre-check: same shape as ``_egg_fragment`` above.
+        if "subdirectory=" not in self._url:
+            return None
         match = self._subdirectory_fragment_re.search(self._url)
         if not match:
             return None

tests/unit/test_link.py

@@ -81,6 +81,33 @@ def test_fragments(self) -> None:
         assert "eggname" == Link(url).egg_fragment
         assert "subdir" == Link(url).subdirectory_fragment
 
+    @pytest.mark.parametrize(
+        "url",
+        [
+            pytest.param(
+                "https://files.pythonhosted.org/packages/12/34/foo-1.0-py3-none-any.whl",
+                id="pypi-wheel",
+            ),
+            pytest.param(
+                "https://files.pythonhosted.org/packages/12/34/foo-1.0-py3-none-any.whl#sha256=abc",
+                id="pypi-wheel-with-hash",
+            ),
+            pytest.param("https://example.com/path/to/file.tar.gz", id="archive"),
+            pytest.param(
+                "https://example.com/path/to/file.tar.gz?build=1",
+                id="archive-with-query",
+            ),
+        ],
+    )
+    def test_fragments_absent_for_typical_links(self, url: str) -> None:
+        """Links served by a Simple-API response have no ``egg=`` or
+        ``subdirectory=`` fragment. The accessors MUST return ``None`` for
+        them (the implementation may take a fast path here).
+        """
+        link = Link(url)
+        assert link.egg_fragment is None
+        assert link.subdirectory_fragment is None
+
     @pytest.mark.parametrize(
         "fragment",
         [