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        if let Some(p) = std::env::var_os(PYTHON_ENV).filter(|p| !p.is_empty()) {
40            return which(&p).map(|path| Self { path, managed: false });
41        }
42        if let Some(d) = data_dir {
43            let p = venv_python(&managed_venv(d));
44            if p.exists() {
45                return Some(Self { path: p, managed: true });
46            }
47        }
48        system_python().map(|path| Self { path, managed: false })
49    }
50
51    /// Folders the sandbox must let this interpreter read (see
52    /// [`byob_sandbox::interpreter_read_paths`]).
53    pub fn read_paths(&self) -> Vec<PathBuf> {
54        byob_sandbox::interpreter_read_paths(self.path.as_os_str())
55    }
56}
57
58/// `python3` (or `python`) on `PATH`, ignoring `$BYOB_PYTHON` and the managed venv.
59pub fn system_python() -> Option<PathBuf> {
60    which(OsStr::new("python3")).or_else(|| which(OsStr::new("python")))
61}
62
63/// A package requirement the model may ask for: a name with optional extras and version
64/// constraints (`pandas`, `scikit-learn>=1.4`, `xarray[io]`). No URLs, paths or options.
65pub fn valid_requirement(s: &str) -> bool {
66    let Some(first) = s.chars().next() else { return false };
67    s.len() <= 100 && first.is_ascii_alphanumeric() && s.chars().all(|c| c.is_ascii_alphanumeric() || "._-[],<>=!~".contains(c))
68}
69
70#[cfg(test)]
71mod tests {
72    use super::*;
73
74    #[test]
75    fn requirements() {
76        for ok in ["pandas", "scikit-learn>=1.4", "xarray[io]", "numpy==2.1.0", "a.b_c"] {
77            assert!(valid_requirement(ok), "{ok}");
78        }
79        for bad in ["", "-r", "--index-url=x", "../x", "git+https://x", "a b", "pkg@ https://x", "/abs", "x;rm", &"a".repeat(101)] {
80            assert!(!valid_requirement(bad), "{bad}");
81        }
82    }
83
84    #[cfg(unix)]
85    #[test]
86    fn venv_read_paths() {
87        use std::os::unix::fs::PermissionsExt;
88        let d = tempfile::tempdir().unwrap();
89        let venv = d.path().join("venv");
90        std::fs::create_dir_all(venv.join("bin")).unwrap();
91        std::fs::write(venv.join("pyvenv.cfg"), "home = /usr/bin\n").unwrap();
92        std::fs::write(venv.join("bin/python"), "").unwrap();
93        std::fs::set_permissions(venv.join("bin/python"), std::fs::Permissions::from_mode(0o755)).unwrap();
94        let p = Python { path: venv.join("bin/python"), managed: true };
95        assert!(p.read_paths().contains(&venv.canonicalize().unwrap()));
96        // a stray binary in a plain folder grants nothing
97        std::fs::create_dir_all(d.path().join("bin")).unwrap();
98        std::fs::write(d.path().join("bin/python3"), "").unwrap();
99        std::fs::set_permissions(d.path().join("bin/python3"), std::fs::Permissions::from_mode(0o755)).unwrap();
100        let p = Python { path: d.path().join("bin/python3"), managed: false };
101        assert!(p.read_paths().is_empty());
102    }
103}