Skip to main content

byob_exec/
python.rs

1//! Which Python runs model code, and the managed environment for data-analysis packages.
2//!
3//! Order: `$BYOB_PYTHON`, then the managed venv `<data>/python/venv` (created by
4//! [`install_python_packages`](crate::InstallPythonPackages) with `uv`), then `python3` /
5//! `python` on `PATH`.
6
7use std::ffi::OsStr;
8use std::path::{Path, PathBuf};
9
10pub use byob_sandbox::which;
11
12/// Overrides the interpreter.
13pub const PYTHON_ENV: &str = "BYOB_PYTHON";
14
15/// The managed environment's folder under the byob data folder.
16pub fn managed_root(data_dir: &Path) -> PathBuf {
17    data_dir.join("python")
18}
19
20pub fn managed_venv(data_dir: &Path) -> PathBuf {
21    managed_root(data_dir).join("venv")
22}
23
24pub fn venv_python(venv: &Path) -> PathBuf {
25    if cfg!(windows) { venv.join("Scripts").join("python.exe") } else { venv.join("bin").join("python") }
26}
27
28/// A resolved interpreter.
29#[derive(Debug, Clone, PartialEq, Eq)]
30pub struct Python {
31    pub path: PathBuf,
32    /// It's byob's managed venv.
33    pub managed: bool,
34}
35
36impl Python {
37    /// Find an interpreter (see the module docs).
38    pub fn resolve(data_dir: Option<&Path>) -> Option<Self> {
39        Self::resolve_in(data_dir, &[])
40    }
41
42    /// Like [`Python::resolve`], but a `python3` in the workspace environment's `PATH`
43    /// entries (installed packages, a `.venv`, the dev shell) comes right after `$BYOB_PYTHON`.
44    pub fn resolve_in(data_dir: Option<&Path>, env_path: &[PathBuf]) -> Option<Self> {
45        if let Some(p) = std::env::var_os(PYTHON_ENV).filter(|p| !p.is_empty()) {
46            return which(&p).map(|path| Self { path, managed: false });
47        }
48        for dir in env_path {
49            for name in ["python3", "python"] {
50                let p = dir.join(if cfg!(windows) { format!("{name}.exe") } else { name.to_owned() });
51                if which(p.as_os_str()).is_some() {
52                    return Some(Self { path: p, managed: false });
53                }
54            }
55        }
56        if let Some(d) = data_dir {
57            let p = venv_python(&managed_venv(d));
58            if p.exists() {
59                return Some(Self { path: p, managed: true });
60            }
61        }
62        system_python().map(|path| Self { path, managed: false })
63    }
64
65    /// Folders the sandbox must let this interpreter read (see
66    /// [`byob_sandbox::interpreter_read_paths`]).
67    pub fn read_paths(&self) -> Vec<PathBuf> {
68        byob_sandbox::interpreter_read_paths(self.path.as_os_str())
69    }
70}
71
72/// `python3` (or `python`) on `PATH`, ignoring `$BYOB_PYTHON` and the managed venv.
73pub fn system_python() -> Option<PathBuf> {
74    which(OsStr::new("python3")).or_else(|| which(OsStr::new("python")))
75}
76
77/// A package requirement the model may ask for: a name with optional extras and version
78/// constraints (`pandas`, `scikit-learn>=1.4`, `xarray[io]`). No URLs, paths or options.
79pub fn valid_requirement(s: &str) -> bool {
80    let Some(first) = s.chars().next() else { return false };
81    s.len() <= 100 && first.is_ascii_alphanumeric() && s.chars().all(|c| c.is_ascii_alphanumeric() || "._-[],<>=!~".contains(c))
82}
83
84#[cfg(test)]
85mod tests {
86    use super::*;
87
88    #[test]
89    fn requirements() {
90        for ok in ["pandas", "scikit-learn>=1.4", "xarray[io]", "numpy==2.1.0", "a.b_c"] {
91            assert!(valid_requirement(ok), "{ok}");
92        }
93        for bad in ["", "-r", "--index-url=x", "../x", "git+https://x", "a b", "pkg@ https://x", "/abs", "x;rm", &"a".repeat(101)] {
94            assert!(!valid_requirement(bad), "{bad}");
95        }
96    }
97
98    #[cfg(unix)]
99    #[test]
100    fn venv_read_paths() {
101        use std::os::unix::fs::PermissionsExt;
102        let d = tempfile::tempdir().unwrap();
103        let venv = d.path().join("venv");
104        std::fs::create_dir_all(venv.join("bin")).unwrap();
105        std::fs::write(venv.join("pyvenv.cfg"), "home = /usr/bin\n").unwrap();
106        std::fs::write(venv.join("bin/python"), "").unwrap();
107        std::fs::set_permissions(venv.join("bin/python"), std::fs::Permissions::from_mode(0o755)).unwrap();
108        let p = Python { path: venv.join("bin/python"), managed: true };
109        assert!(p.read_paths().contains(&venv.canonicalize().unwrap()));
110        // a stray binary in a plain folder grants nothing
111        std::fs::create_dir_all(d.path().join("bin")).unwrap();
112        std::fs::write(d.path().join("bin/python3"), "").unwrap();
113        std::fs::set_permissions(d.path().join("bin/python3"), std::fs::Permissions::from_mode(0o755)).unwrap();
114        let p = Python { path: d.path().join("bin/python3"), managed: false };
115        assert!(p.read_paths().is_empty());
116    }
117}