[WIP] Support system-site-packages access when create venv

CHANGELOG.md

@@ -9,6 +9,9 @@ _Unreleased_
 
 - Always create `.gitignore` file in `rye init`.  #919
 
+- Added new `rye.tool.system-site-packages` config, so that the virtualenv
+  can be created with access to the system site packages.  #925
+
 <!-- released start -->
 
 ## 0.31.0

rye/src/bootstrap.rs

@@ -16,7 +16,7 @@ use crate::piptools::LATEST_PIP;
 use crate::platform::{
     get_app_dir, get_canonical_py_path, get_toolchain_python_bin, list_known_toolchains,
 };
-use crate::pyproject::latest_available_python_version;
+use crate::pyproject::{latest_available_python_version, PyProject};
 use crate::sources::py::{get_download_url, PythonVersion, PythonVersionRequest};
 use crate::utils::{check_checksum, symlink_file, unpack_archive, CommandOutput, IoPathContext};
 use crate::uv::UvBuilder;
@@ -142,6 +142,8 @@ pub fn ensure_self_venv_with_toolchain(
 
     let py_bin = get_toolchain_python_bin(&version)?;
 
+    let pyproject = PyProject::discover()?;
+
     // linux specific detection of shared libraries.
     #[cfg(target_os = "linux")]
     {
@@ -150,7 +152,13 @@ pub fn ensure_self_venv_with_toolchain(
 
     // initialize the virtualenv
     {
-        let uv_venv = uv.venv(&venv_dir, &py_bin, &version, None)?;
+        let uv_venv = uv.venv(
+            &venv_dir,
+            &py_bin,
+            &version,
+            None,
+            pyproject.system_site_packages(),
+        )?;
         // write our marker
         uv_venv.write_marker()?;
         // update pip and our requirements

rye/src/cli/add.rs

@@ -452,12 +452,19 @@ fn resolve_requirements_with_uv(
     let venv_path = pyproject_toml.venv_path();
     let py_bin = get_venv_python_bin(&venv_path);
     let sources = ExpandedSources::from_sources(&pyproject_toml.sources()?)?;
+    let pyproject = PyProject::discover()?;
 
     let uv = UvBuilder::new()
         .with_output(output.quieter())
         .with_sources(sources)
         .ensure_exists()?
-        .venv(&venv_path, &py_bin, py_ver, None)?;
+        .venv(
+            &venv_path,
+            &py_bin,
+            py_ver,
+            None,
+            pyproject.system_site_packages(),
+        )?;
 
     for req in requirements {
         let mut new_req = uv.resolve(py_ver, req, pre, env::var("__RYE_UV_EXCLUDE_NEWER").ok())?;

rye/src/cli/list.rs

@@ -36,6 +36,7 @@ pub fn execute(cmd: Args) -> Result<(), Error> {
                 &python,
                 &project.venv_python_version()?,
                 None,
+                project.system_site_packages(),
             )?
             .freeze()?;
     } else {

rye/src/installer.rs

@@ -139,14 +139,15 @@ pub fn install(
         &py_ver,
         &target_venv_path,
         requirement.name.as_str(),
+        false,
     )?;
 
-    if Config::current().use_uv() {
+    if config.use_uv() {
         let result = UvBuilder::new()
             .with_output(output.quieter())
             .with_sources(sources)
             .ensure_exists()?
-            .venv(&target_venv_path, &py, &py_ver, None)?
+            .venv(&target_venv_path, &py, &py_ver, None, false)?
             .with_output(output)
             .install(
                 &requirement,

rye/src/piptools.rs

@@ -55,7 +55,7 @@ fn get_pip_tools_bin(py_ver: &PythonVersion, output: CommandOutput) -> Result<Pa
     }
 
     echo!(if output, "Creating virtualenv for pip-tools");
-    create_virtualenv(output, &self_venv, py_ver, &venv, "pip-tools")?;
+    create_virtualenv(output, &self_venv, py_ver, &venv, "pip-tools", false)?;
 
     let mut cmd = Command::new(self_venv.join(VENV_BIN).join("pip"));
     cmd.arg("--python")

rye/src/pyproject.rs

@@ -539,6 +539,11 @@ impl Workspace {
     pub fn lock_with_sources(&self) -> bool {
         lock_with_sources(&self.doc)
     }
+
+    /// Include system site packages when creating virtualenvs?
+    pub fn system_site_packages(&self) -> bool {
+        system_site_packages(&self.doc)
+    }
 }
 
 /// Check if recurse should be skipped into directory with this name
@@ -1005,6 +1010,14 @@ impl PyProject {
         }
     }
 
+    /// Include system site packages when creating virtualenvs?
+    pub fn system_site_packages(&self) -> bool {
+        match self.workspace {
+            Some(ref workspace) => workspace.system_site_packages(),
+            None => system_site_packages(&self.doc),
+        }
+    }
+
     /// Save back changes
     pub fn save(&self) -> Result<(), Error> {
         let path = self.toml_path();
@@ -1279,6 +1292,14 @@ fn lock_with_sources(doc: &Document) -> bool {
         .unwrap_or(false)
 }
 
+fn system_site_packages(doc: &Document) -> bool {
+    doc.get("tool")
+        .and_then(|x| x.get("rye"))
+        .and_then(|x| x.get("system-site-packages"))
+        .and_then(|x| x.as_bool())
+        .unwrap_or(false)
+}
+
 fn get_project_metadata(path: &Path) -> Result<Metadata, Error> {
     let self_venv = ensure_self_venv(CommandOutput::Normal)?;
     let mut metadata = Command::new(self_venv.join(VENV_BIN).join("python"));

rye/src/sync.rs

@@ -169,8 +169,15 @@ pub fn sync(mut cmd: SyncOptions) -> Result<(), Error> {
         );
         echo!(if output, "Python version: {}", style(&py_ver).cyan());
         let prompt = pyproject.name().unwrap_or("venv");
-        create_virtualenv(output, &self_venv, &py_ver, &venv, prompt)
-            .context("failed creating virtualenv ahead of sync")?;
+        create_virtualenv(
+            output,
+            &self_venv,
+            &py_ver,
+            &venv,
+            prompt,
+            pyproject.system_site_packages(),
+        )
+        .context("failed creating virtualenv ahead of sync")?;
     }
 
     // prepare necessary utilities for pip-sync.  This is a super crude
@@ -251,7 +258,13 @@ pub fn sync(mut cmd: SyncOptions) -> Result<(), Error> {
                     .with_workdir(&pyproject.workspace_path())
                     .with_sources(sources)
                     .ensure_exists()?
-                    .venv(&venv, &py_path, &py_ver, None)?
+                    .venv(
+                        &venv,
+                        &py_path,
+                        &py_ver,
+                        None,
+                        pyproject.system_site_packages(),
+                    )?
                     .with_output(output)
                     .sync(&target_lockfile)?;
             } else {
@@ -328,6 +341,7 @@ pub fn create_virtualenv(
     py_ver: &PythonVersion,
     venv: &Path,
     prompt: &str,
+    system_site_packages: bool,
 ) -> Result<(), Error> {
     let py_bin = get_toolchain_python_bin(py_ver)?;
 
@@ -337,7 +351,7 @@ pub fn create_virtualenv(
         let uv = UvBuilder::new()
             .with_output(output.quieter())
             .ensure_exists()?
-            .venv(venv, &py_bin, py_ver, Some(prompt))
+            .venv(venv, &py_bin, py_ver, Some(prompt), system_site_packages)
             .context("failed to initialize virtualenv")?;
         uv.write_marker()?;
         uv.sync_marker();

rye/src/uv.rs

@@ -262,12 +262,13 @@ impl Uv {
         py_bin: &Path,
         version: &PythonVersion,
         prompt: Option<&str>,
+        system_site_packages: bool,
     ) -> Result<UvWithVenv, Error> {
         match read_venv_marker(venv_dir) {
             Some(venv) if venv.is_compatible(version) => {
                 Ok(UvWithVenv::new(self.clone(), venv_dir, version))
             }
-            _ => self.create_venv(venv_dir, py_bin, version, prompt),
+            _ => self.create_venv(venv_dir, py_bin, version, prompt, system_site_packages),
         }
     }
 
@@ -277,12 +278,16 @@ impl Uv {
         py_bin: &Path,
         version: &PythonVersion,
         prompt: Option<&str>,
+        system_site_packages: bool,
     ) -> Result<UvWithVenv, Error> {
         let mut cmd = self.cmd();
         cmd.arg("venv").arg("--python").arg(py_bin);
         if let Some(prompt) = prompt {
             cmd.arg("--prompt").arg(prompt);
         }
+        if system_site_packages {
+            cmd.arg("--system-site-packages");
+        }
         cmd.arg(venv_dir);
         let status = cmd.status().with_context(|| {
             format!(

rye/tests/test_sync.rs

@@ -1,8 +1,8 @@
 use std::fs;
 
-use insta::{assert_snapshot, Settings};
-
 use crate::common::{rye_cmd_snapshot, Space};
+use insta::{assert_snapshot, Settings};
+use toml_edit::value;
 
 mod common;
 
@@ -261,3 +261,18 @@ fn test_autosync_remember() {
     werkzeug==3.0.1
     "###);
 }
+
+#[test]
+fn test_sync_include_system_site_packages() {
+    let space = Space::new();
+    space.init("my-project");
+    space.edit_toml("pyproject.toml", |doc| {
+        doc["tool"]["rye"]["system-site-packages"] = value(true);
+    });
+
+    space.rye_cmd().arg("sync").status().expect("ok");
+
+    assert!(fs::read_to_string(space.venv_path().join("pyvenv.cfg"))
+        .unwrap()
+        .contains("include-system-site-packages = true"));
+}