fix: git URLs working with bootstrap-parallel

The bootstrap-parallel command failed when top-level requirements were
specified as git URLs. During the bootstrap phase, git URLs were
correctly stored in the dependency graph, but the build-parallel phase
reconstructed requirements as name==version, losing the URL
information. This caused the system to treat local directory paths as
HTTP URLs, resulting in invalid URL errors.

Changes:
- Add get_top_level_requirement() method to DependencyGraph that
  efficiently retrieves original requirement specifications by iterating
  through node parents instead of ROOT children
- Modify build_parallel() to use original top-level requirements only
  when they contain URLs, ensuring non-URL requirements always use the
  already-resolved version from the graph
- Move urlparse import to top of sources.py following PEP 8 guidelines
- Add URL parsing logic in download_source() to extract @ref from git
  URLs (e.g., repo.git@5.2.0) before calling download_git_source()

This fix enables nightly build pipelines that rely on git URLs with
the bootstrap-parallel command for faster builds.

Now #762 can be revisited.

Fixes: #761

Co-authored-by: Claude <claude@anthropic.com>

Signed-off-by: Ioannis Angelakopoulos <iangelak@redhat.com>

Author: iangelak

src/fromager/commands/build.py

@@ -696,7 +696,19 @@ def update_progressbar_cb(future: concurrent.futures.Future) -> None:
                     "starting to build: %s", sorted(n.key for n in buildable_nodes)
                 )
                 for node in buildable_nodes:
-                    req = Requirement(f"{node.canonicalized_name}=={node.version}")
+                    # Try to get the original top-level requirement if it includes a URL.
+                    # We only use the top-level requirement if:
+                    # 1. The node is a direct child of ROOT (it's actually top-level)
+                    # 2. The requirement includes a URL (git, etc.)
+                    # Otherwise, we use the already-resolved version from the node to avoid:
+                    # - Building wrong versions when same package appears multiple times
+                    # - Re-resolving unpinned version specifiers
+                    top_level_req = graph.get_top_level_requirement(node)
+                    if top_level_req and top_level_req.url:
+                        req = top_level_req
+                        logger.debug("using top-level requirement with URL: %s", req)
+                    else:
+                        req = Requirement(f"{node.canonicalized_name}=={node.version}")
                     reqs.append(req)
                     future = executor.submit(
                         _build_parallel,

src/fromager/dependency_graph.py

@@ -352,6 +352,19 @@ def get_nodes_by_name(self, req_name: str | None) -> list[DependencyNode]:
     def get_root_node(self) -> DependencyNode:
         return self.nodes[ROOT]
 
+    def get_top_level_requirement(self, node: DependencyNode) -> Requirement | None:
+        """Get the top-level requirement specification for a node.
+
+        For packages that were specified as top-level requirements (e.g., with git URLs),
+        this returns the original requirement specification. Returns None if the node
+        is not a direct child of ROOT.
+        """
+        root = self.get_root_node()
+        for edge in node.parents:
+            if edge.parent_node is root:
+                return edge.req
+        return None
+
     def get_all_nodes(self) -> typing.Iterable[DependencyNode]:
         return self.nodes.values()
 

src/fromager/sources.py

@@ -8,6 +8,7 @@
 import tarfile
 import typing
 import zipfile
+from urllib.parse import urlparse
 
 import resolvelib
 from packaging.requirements import Requirement
@@ -77,11 +78,32 @@ def download_source(
     elif req.url:
         download_path = ctx.work_dir / f"{req.name}-{version}" / f"{req.name}-{version}"
         download_path.mkdir(parents=True, exist_ok=True)
+
+        # Parse ref from URL if it's in the form repo@ref
+        url_to_clone = req.url
+        git_ref: str | None = None
+
+        # Remove git+ prefix for parsing
+        parsing_url = url_to_clone
+        if parsing_url.startswith("git+"):
+            parsing_url = parsing_url[len("git+") :]
+
+        parsed_url = urlparse(parsing_url)
+        if "@" in parsed_url.path:
+            # Extract the ref from the path (e.g., /path/to/repo.git@5.2.0 -> @5.2.0)
+            new_path, _, git_ref = parsed_url.path.rpartition("@")
+            # Reconstruct URL without the @ref part
+            url_to_clone = parsed_url._replace(path=new_path).geturl()
+            # Add back git+ prefix if it was present
+            if req.url.startswith("git+"):
+                url_to_clone = f"git+{url_to_clone}"
+
         download_git_source(
             ctx=ctx,
             req=req,
-            url_to_clone=req.url,
+            url_to_clone=url_to_clone,
             destination_dir=download_path,
+            ref=git_ref,
         )
         return download_path