1use std::ffi::OsStr;
8use std::path::{Path, PathBuf};
9
10pub use byob_sandbox::which;
11
12pub const PYTHON_ENV: &str = "BYOB_PYTHON";
14
15pub 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#[derive(Debug, Clone, PartialEq, Eq)]
30pub struct Python {
31 pub path: PathBuf,
32 pub managed: bool,
34}
35
36impl Python {
37 pub fn resolve(data_dir: Option<&Path>) -> Option<Self> {
39 Self::resolve_in(data_dir, &[])
40 }
41
42 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 pub fn read_paths(&self) -> Vec<PathBuf> {
68 byob_sandbox::interpreter_read_paths(self.path.as_os_str())
69 }
70}
71
72pub fn system_python() -> Option<PathBuf> {
74 which(OsStr::new("python3")).or_else(|| which(OsStr::new("python")))
75}
76
77pub 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 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}