Fix pex build for pyproject.tomls with tool.uv.sources defined (#33080)

## Summary & Motivation

When parsing out local dependencies, we were not properly handling uv
sources.

This PR handles both standard single-project setups (where the
tool.uv.sources will just contain the relative path directly), as well
as uv workspaces (where tool.uv.sources will just contain `workspace =
true`, which requires us to scan upwards to find the workspace config
file.

## How I Tested These Changes

## Changelog

> Insert changelog entry or delete this section.

Author: OwenKephart

python_modules/libraries/dagster-cloud-cli/dagster_cloud_cli/core/pex_builder/deps.py

@@ -388,6 +388,51 @@ def get_setup_py_deps(code_directory: str, python_interpreter: str) -> list[str]
     return lines
 
 
+def _read_pyproject_toml(directory: str) -> Optional[dict]:
+    """Read and parse pyproject.toml from a directory. Returns None if not found."""
+    pyproject_path = os.path.join(directory, "pyproject.toml")
+    if not os.path.exists(pyproject_path):
+        return None
+    with open(pyproject_path, "rb") as f:
+        return tomllib.load(f)
+
+
+def _find_uv_workspace_root(start_dir: str) -> Optional[tuple[str, dict]]:
+    """Walk up directories to find a uv workspace root.
+
+    Returns (workspace_root_path, workspace_config) or None if not found.
+    """
+    current = os.path.abspath(start_dir)
+    while True:
+        data = _read_pyproject_toml(current)
+        if data:
+            workspace_config = data.get("tool", {}).get("uv", {}).get("workspace", {})
+            if workspace_config:
+                return current, workspace_config
+        parent = os.path.dirname(current)
+        if parent == current:
+            return None
+        current = parent
+
+
+def _resolve_uv_workspace_dep(dep_name: str, code_directory: str) -> Optional[str]:
+    """Find the relative path to a uv workspace member by package name.
+
+    Returns a relative path like "../shared-lib" or None if not found.
+    Assumes the directory name matches the package name.
+    """
+    result = _find_uv_workspace_root(code_directory)
+    if not result:
+        return None
+
+    workspace_root, _ = result
+    candidate = os.path.join(workspace_root, dep_name)
+    if os.path.isdir(candidate):
+        return os.path.relpath(candidate, code_directory)
+
+    return None
+
+
 def get_pyproject_toml_deps(code_directory: str) -> list[str]:
     pyproject_path = os.path.join(code_directory, "pyproject.toml")
     if not os.path.exists(pyproject_path):
@@ -442,6 +487,24 @@ def get_pyproject_toml_deps(code_directory: str) -> list[str]:
             else:
                 lines.append(dep_name)
 
+    # Handle [tool.uv.sources] - resolve workspace and path dependencies to local paths
+    uv_sources = pyproject_data.get("tool", {}).get("uv", {}).get("sources", {})
+    if uv_sources:
+        resolved_lines = []
+        for line in lines:
+            source_config = uv_sources.get(line)
+            if source_config:
+                if source_config.get("workspace"):
+                    resolved_path = _resolve_uv_workspace_dep(line, code_directory)
+                    if resolved_path:
+                        resolved_lines.append(resolved_path)
+                        continue
+                elif "path" in source_config:
+                    resolved_lines.append(source_config["path"])
+                    continue
+            resolved_lines.append(line)
+        return resolved_lines
+
     return lines
 
 

python_modules/libraries/dagster-cloud-cli/dagster_cloud_cli_tests/test_pyproject_toml_support.py

@@ -548,6 +548,153 @@ def test_get_deps_requirements_multi_location_scenario(tmp_path):
     )
 
 
+def test_get_deps_requirements_uv_sources_path(tmp_path):
+    """Test get_deps_requirements handles [tool.uv.sources] with path (no workspace)."""
+    python_version = version.Version(f"{sys.version_info.major}.{sys.version_info.minor}")
+
+    # Create main package
+    app_dir = tmp_path / "my-app"
+    app_dir.mkdir()
+    (app_dir / "my_app").mkdir()
+    (app_dir / "my_app" / "__init__.py").write_text("")
+    (app_dir / "pyproject.toml").write_text("""
+[project]
+name = "my-app"
+version = "0.1.0"
+dependencies = [
+    "dagster>=1.0.0",
+    "dagster-cloud>=1.0.0",
+    "local-utils",
+]
+
+[tool.uv.sources]
+local-utils = { path = "../local-utils" }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+""")
+
+    # Create local-utils as a sibling package (not a workspace member)
+    local_utils_dir = tmp_path / "local-utils"
+    local_utils_dir.mkdir()
+    (local_utils_dir / "local_utils").mkdir()
+    (local_utils_dir / "local_utils" / "__init__.py").write_text("")
+    (local_utils_dir / "pyproject.toml").write_text("""
+[project]
+name = "local-utils"
+version = "0.1.0"
+dependencies = ["pydantic>=2.0.0"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+""")
+
+    # Get deps from the app directory
+    local_packages, deps_requirements = deps.get_deps_requirements(str(app_dir), python_version)
+
+    deps_lines = [
+        line.strip()
+        for line in deps_requirements.requirements_txt.strip().split("\n")
+        if line.strip()
+    ]
+
+    # External deps should be in requirements
+    assert any("dagster>=" in dep for dep in deps_lines), f"dagster not found in {deps_lines}"
+
+    # local-utils should be detected as a local package via path source
+    assert str(local_utils_dir) in local_packages.local_package_paths, (
+        f"local-utils should be in local_package_paths: {local_packages.local_package_paths}"
+    )
+    assert not any("local-utils" in dep for dep in deps_lines), (
+        f"local-utils should NOT be in deps (it's a local package): {deps_lines}"
+    )
+
+
+def test_get_deps_requirements_uv_workspace(tmp_path):
+    """Test get_deps_requirements correctly handles uv workspace local dependencies.
+
+    When a uv workspace member has dependencies on other workspace members
+    (via [tool.uv.sources] with workspace = true), those should be detected
+    as local packages and included in local_package_paths.
+    """
+    python_version = version.Version(f"{sys.version_info.major}.{sys.version_info.minor}")
+
+    # Create workspace root
+    workspace_root = tmp_path
+    (workspace_root / "pyproject.toml").write_text("""
+[project]
+name = "my-workspace"
+version = "0.1.0"
+
+[tool.uv.workspace]
+members = ["my-app", "shared-lib"]
+""")
+
+    # Create main app package
+    app_dir = workspace_root / "my-app"
+    app_dir.mkdir()
+    (app_dir / "my_app").mkdir()
+    (app_dir / "my_app" / "__init__.py").write_text("")
+    (app_dir / "pyproject.toml").write_text("""
+[project]
+name = "my-app"
+version = "0.1.0"
+dependencies = [
+    "dagster>=1.0.0",
+    "dagster-cloud>=1.0.0",
+    "requests>=2.25.0",
+    "shared-lib",
+]
+
+[tool.uv.sources]
+shared-lib = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+""")
+
+    # Create shared-lib workspace member
+    shared_lib_dir = workspace_root / "shared-lib"
+    shared_lib_dir.mkdir()
+    (shared_lib_dir / "shared_lib").mkdir()
+    (shared_lib_dir / "shared_lib" / "__init__.py").write_text("")
+    (shared_lib_dir / "pyproject.toml").write_text("""
+[project]
+name = "shared-lib"
+version = "0.1.0"
+dependencies = ["pydantic>=2.0.0"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+""")
+
+    # Get deps from the app directory
+    local_packages, deps_requirements = deps.get_deps_requirements(str(app_dir), python_version)
+
+    deps_lines = [
+        line.strip()
+        for line in deps_requirements.requirements_txt.strip().split("\n")
+        if line.strip()
+    ]
+
+    # External deps should be in requirements
+    assert any("dagster>=" in dep for dep in deps_lines), f"dagster not found in {deps_lines}"
+    assert any("requests" in dep for dep in deps_lines), f"requests not found in {deps_lines}"
+
+    # shared-lib is a workspace dependency - it should be detected as a local package
+    # and NOT appear in the requirements (it would fail pip install)
+    assert str(shared_lib_dir) in local_packages.local_package_paths, (
+        f"shared-lib should be in local_package_paths: {local_packages.local_package_paths}"
+    )
+    assert not any("shared-lib" in dep for dep in deps_lines), (
+        f"shared-lib should NOT be in deps (it's a local package): {deps_lines}"
+    )
+
+
 def test_get_pyproject_deps_requirements_multi_location_scenario() -> None:
     """Test scenario that mimics multi-location build with nested packages.