pick up site packages from the interpreter's sys.path

.github/workflows/ci.yml

@@ -656,7 +656,7 @@ jobs:
           yum install tar gzip which -y
       - uses: actions/checkout@v4
       - name: "Install Python"
-        run: yum install python3 python3-pip -y
+        run: yum install python3 -y && python3 -m ensurepip
 
       - name: "Download binary"
         uses: actions/download-artifact@v4

crates/uv-build/src/lib.rs

@@ -31,7 +31,8 @@ use pep508_rs::{PackageName, Requirement};
 use uv_fs::{PythonExt, Simplified};
 use uv_interpreter::{Interpreter, PythonEnvironment};
 use uv_types::{
-    BuildContext, BuildIsolation, BuildKind, ConfigSettings, SetupPyStrategy, SourceBuildTrait,
+    BuildContext, BuildIsolation, BuildKind, ConfigSettings, Reinstall, SetupPyStrategy,
+    SourceBuildTrait,
 };
 
 /// e.g. `pygraphviz/graphviz_wrap.c:3020:10: fatal error: graphviz/cgraph.h: No such file or directory`
@@ -432,7 +433,7 @@ impl SourceBuild {
             .await?;
 
             build_context
-                .install(&resolved_requirements, &venv)
+                .install(&resolved_requirements, &venv, &Reinstall::None)
                 .await
                 .map_err(|err| {
                     Error::RequirementsInstall("build-system.requires (install)", err)
@@ -975,7 +976,7 @@ async fn create_pep517_build_environment(
             .map_err(|err| Error::RequirementsInstall("build-system.requires (resolve)", err))?;
 
         build_context
-            .install(&resolution, venv)
+            .install(&resolution, venv, &Reinstall::None)
             .await
             .map_err(|err| Error::RequirementsInstall("build-system.requires (install)", err))?;
     }

crates/uv-dispatch/src/lib.rs

@@ -159,16 +159,18 @@ impl<'a> BuildContext for BuildDispatch<'a> {
 
     #[allow(clippy::manual_async_fn)] // TODO(konstin): rustc 1.75 gets into a type inference cycle with async fn
     #[instrument(
-        skip(self, resolution, venv),
+        skip(self, resolution, venv, reinstall),
         fields(
             resolution = resolution.distributions().map(ToString::to_string).join(", "),
-            venv = ?venv.root()
+            venv = ?venv.root(),
+            reinstall = ?reinstall
         )
     )]
     fn install<'data>(
         &'data self,
         resolution: &'data Resolution,
         venv: &'data PythonEnvironment,
+        reinstall: &'data Reinstall,
     ) -> impl Future<Output = Result<()>> + Send + 'data {
         async move {
             debug!(
@@ -194,7 +196,7 @@ impl<'a> BuildContext for BuildDispatch<'a> {
                 extraneous: _,
             } = Planner::with_requirements(&resolution.requirements()).build(
                 site_packages,
-                &Reinstall::None,
+                reinstall,
                 &NoBinary::None,
                 self.index_locations,
                 self.cache(),

crates/uv-installer/src/site_packages.rs

@@ -48,12 +48,7 @@ impl<'a> SitePackages<'a> {
             let site_packages = match fs::read_dir(site_packages) {
                 Ok(site_packages) => site_packages,
                 Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
-                    return Ok(Self {
-                        venv,
-                        distributions,
-                        by_name,
-                        by_url,
-                    });
+                    continue;
                 }
                 Err(err) => return Err(err).context("Failed to read site-packages directory"),
             };
@@ -73,7 +68,6 @@ impl<'a> SitePackages<'a> {
                     };
 
                     let idx = distributions.len();
-
                     // Index the distribution by name.
                     by_name
                         .entry(dist_info.name().clone())

crates/uv-interpreter/python/get_interpreter_info.py

@@ -520,6 +520,7 @@ def main() -> None:
         "prefix": sys.prefix,
         "base_executable": getattr(sys, "_base_executable", None),
         "sys_executable": sys.executable,
+        "sys_path": sys.path,
         "stdlib": sysconfig.get_path("stdlib"),
         "scheme": get_scheme(),
         "virtualenv": get_virtualenv(),

crates/uv-interpreter/src/interpreter.rs

@@ -32,6 +32,7 @@ pub struct Interpreter {
     base_prefix: PathBuf,
     base_executable: Option<PathBuf>,
     sys_executable: PathBuf,
+    sys_path: Vec<PathBuf>,
     stdlib: PathBuf,
     tags: OnceCell<Tags>,
 }
@@ -57,6 +58,7 @@ impl Interpreter {
             base_prefix: info.base_prefix,
             base_executable: info.base_executable,
             sys_executable: info.sys_executable,
+            sys_path: info.sys_path,
             stdlib: info.stdlib,
             tags: OnceCell::new(),
         })
@@ -86,6 +88,7 @@ impl Interpreter {
             base_prefix: PathBuf::from("/dev/null"),
             base_executable: None,
             sys_executable: PathBuf::from("/dev/null"),
+            sys_path: vec![],
             stdlib: PathBuf::from("/dev/null"),
             tags: OnceCell::new(),
         }
@@ -254,6 +257,14 @@ impl Interpreter {
         &self.sys_executable
     }
 
+    /// Return the `sys.path` for this Python interpreter.
+    pub fn sys_path(&self) -> Vec<&Path> {
+        self.sys_path
+            .iter()
+            .map(std::path::PathBuf::as_path)
+            .collect::<Vec<&Path>>()
+    }
+
     /// Return the `stdlib` path for this Python interpreter, as returned by `sysconfig.get_paths()`.
     pub fn stdlib(&self) -> &Path {
         &self.stdlib
@@ -360,6 +371,7 @@ struct InterpreterInfo {
     base_prefix: PathBuf,
     base_executable: Option<PathBuf>,
     sys_executable: PathBuf,
+    sys_path: Vec<PathBuf>,
     stdlib: PathBuf,
 }
 
@@ -576,6 +588,7 @@ mod tests {
                 "base_prefix": "/home/ferris/.pyenv/versions/3.12.0",
                 "prefix": "/home/ferris/projects/uv/.venv",
                 "sys_executable": "/home/ferris/projects/uv/.venv/bin/python",
+                "sys_path": [],
                 "stdlib": "/home/ferris/.pyenv/versions/3.12.0/lib/python3.12",
                 "scheme": {
                     "data": "/home/ferris/.pyenv/versions/3.12.0",

crates/uv-interpreter/src/python_environment.rs

@@ -1,3 +1,4 @@
+use std::collections::HashSet;
 use std::env;
 use std::path::{Path, PathBuf};
 
@@ -89,17 +90,31 @@ impl PythonEnvironment {
     }
 
     /// Returns an iterator over the `site-packages` directories inside a virtual environment.
-    ///
-    /// In most cases, `purelib` and `platlib` will be the same, and so the iterator will contain
-    /// a single element; however, in some distributions, they may be different.
     pub fn site_packages(&self) -> impl Iterator<Item = &Path> {
-        std::iter::once(self.interpreter.purelib()).chain(
-            if self.interpreter.purelib() == self.interpreter.platlib() {
-                None
-            } else {
-                Some(self.interpreter.platlib())
-            },
-        )
+        let mut site_packages = Vec::new();
+        site_packages.push(self.interpreter.purelib());
+        site_packages.push(self.interpreter.platlib());
+        site_packages.extend(
+            self.interpreter
+                .sys_path()
+                .iter()
+                .filter(|path| path.ends_with("site-packages") || path.ends_with("dist-packages")),
+        );
+        // de-duplicate while preserving order
+        let mut dedup_set = HashSet::new();
+        let mut valid_site_packages = site_packages
+            .into_iter()
+            .filter(|path| fs_err::canonicalize(path).is_ok())
+            .collect::<Vec<_>>();
+        valid_site_packages.retain(|path| dedup_set.insert(fs_err::canonicalize(path).unwrap()));
+        debug!(
+            "Site packages: {:?}",
+            valid_site_packages
+                .iter()
+                .map(|p| p.simplified_display())
+                .collect::<Vec<_>>()
+        );
+        valid_site_packages.into_iter()
     }
 
     /// Returns the path to the `bin` directory inside a virtual environment.

crates/uv-resolver/tests/resolver.rs

@@ -22,7 +22,7 @@ use uv_resolver::{
 };
 use uv_types::{
     BuildContext, BuildIsolation, BuildKind, Constraints, EmptyInstalledPackages, NoBinary,
-    NoBuild, Overrides, SetupPyStrategy, SourceBuildTrait,
+    NoBuild, Overrides, Reinstall, SetupPyStrategy, SourceBuildTrait,
 };
 
 // Exclude any packages uploaded after this date.
@@ -83,7 +83,12 @@ impl BuildContext for DummyContext {
         panic!("The test should not need to build source distributions")
     }
 
-    async fn install<'a>(&'a self, _: &'a Resolution, _: &'a PythonEnvironment) -> Result<()> {
+    async fn install<'a>(
+        &'a self,
+        _: &'a Resolution,
+        _: &'a PythonEnvironment,
+        _: &'a Reinstall,
+    ) -> Result<()> {
         panic!("The test should not need to build source distributions")
     }
 

crates/uv-types/src/traits.rs

@@ -9,7 +9,7 @@ use pep508_rs::{PackageName, Requirement};
 use uv_cache::Cache;
 use uv_interpreter::{Interpreter, PythonEnvironment};
 
-use crate::{BuildIsolation, BuildKind, NoBinary, NoBuild, SetupPyStrategy};
+use crate::{BuildIsolation, BuildKind, NoBinary, NoBuild, Reinstall, SetupPyStrategy};
 
 ///  Avoids cyclic crate dependencies between resolver, installer and builder.
 ///
@@ -87,6 +87,7 @@ pub trait BuildContext: Sync {
         &'a self,
         resolution: &'a Resolution,
         venv: &'a PythonEnvironment,
+        reinstall: &'a Reinstall,
     ) -> impl Future<Output = Result<()>> + Send + 'a;
 
     /// Setup a source distribution build by installing the required dependencies. A wrapper for

crates/uv/src/commands/venv.rs

@@ -21,7 +21,8 @@ use uv_fs::Simplified;
 use uv_interpreter::{find_default_python, find_requested_python, Error};
 use uv_resolver::{InMemoryIndex, OptionsBuilder};
 use uv_types::{
-    BuildContext, BuildIsolation, ConfigSettings, InFlight, NoBinary, NoBuild, SetupPyStrategy,
+    BuildContext, BuildIsolation, ConfigSettings, InFlight, NoBinary, NoBuild, Reinstall,
+    SetupPyStrategy,
 };
 
 use crate::commands::ExitStatus;
@@ -208,7 +209,7 @@ async fn venv_impl(
 
         // Install into the environment.
         build_dispatch
-            .install(&resolution, &venv)
+            .install(&resolution, &venv, &Reinstall::All)
             .await
             .map_err(VenvError::Seed)?;