use crate::shell::{CommandOutput, Shell};
use std::io::Cursor;
const PIP_INSTALL_HELP: &str = "\
Usage: pip install [PACKAGE]...
pip-install [PACKAGE]...
pip3 install [PACKAGE]...
python3 -m pip install [PACKAGE]...
pip list | pip freeze | pip show NAME | pip uninstall NAME
Install pure-Python packages from PyPI into site-packages/.
Only py3-none-any.whl (pure Python, no C extensions) are accepted.
Packages with .so/.pyd files are rejected with an error.
Networking uses the same HTTP stack as `curl` (with retries). Set
FASTSHELL_PYPI_INDEX to use a mirror (e.g. https://pypi.tuna.tsinghua.edu.cn).
Options:
-l, --list list installed packages
-h, --help display this help and exit
";
impl Shell {
pub fn cmd_pip_install(&self, args: &[&str]) -> CommandOutput {
let mut packages = Vec::new();
let mut list_mode = false;
let mut i = 0;
while i < args.len() {
match args[i] {
"-h" | "--help" => return CommandOutput::success(PIP_INSTALL_HELP.to_string()),
"-l" | "--list" | "list" => list_mode = true,
"-r" | "--requirement" => {
if i + 1 < args.len() {
if let Ok(content) = self.read_text_lossy(args[i + 1]) {
for line in content.lines() {
let l = line.trim();
if !l.is_empty() && !l.starts_with('#') {
packages.push(l.to_string());
}
}
}
i += 1;
}
}
a if a.starts_with('-') => {}
a => packages.push(a.to_string()),
}
i += 1;
}
if list_mode {
return self.cmd_pip_list();
}
if packages.is_empty() {
return CommandOutput::error("pip-install: missing package name(s)\n".to_string(), 1);
}
let cache_dir = std::env::var("FASTSHELL_WHEEL_CACHE")
.ok()
.map(std::path::PathBuf::from)
.unwrap_or_else(|| std::path::PathBuf::from(".wheel_cache"));
let site_dir = "site-packages";
let mut output = String::new();
let mut failures = 0;
for pkg in &packages {
match install_package(pkg, &cache_dir, site_dir, &self.vfs, &self.cwd) {
Ok(msg) => {
output.push_str(&format!("installed {}\n", pkg));
if !msg.is_empty() {
output.push_str(&format!(" {}\n", msg));
}
}
Err(e) => {
output.push_str(&format!("{}: error: {}\n", pkg, e));
failures += 1;
}
}
}
if failures > 0 {
CommandOutput::error(output, 1)
} else {
CommandOutput::success(output)
}
}
pub fn cmd_pip(&mut self, args: &[&str]) -> CommandOutput {
match args.first().copied() {
Some("install") => self.cmd_pip_install(&args[1..]),
Some("list") | Some("freeze") => self.cmd_pip_install(&["--list"]),
Some("show") => match args.get(1) {
Some(n) => self.cmd_pip_show(n),
None => {
CommandOutput::error("ERROR: pip show requires a package name.\n".into(), 1)
}
},
Some("uninstall") => match args.get(1) {
Some(n) => self.cmd_pip_uninstall(n),
None => CommandOutput::error(
"ERROR: pip uninstall requires a package name.\n".into(),
1,
),
},
Some("-h") | Some("--help") | None => self.cmd_pip_install(&["-h"]),
_ => CommandOutput::error(
"pip: supported: install/list/freeze/show/uninstall.\n".to_string(),
1,
),
}
}
pub fn cmd_pip_show(&self, name: &str) -> CommandOutput {
let site_dir = "site-packages";
let entries = match self.vfs.list_dir(site_dir, &self.cwd) {
Ok(e) => e,
Err(_) => {
return CommandOutput::error(
format!("WARNING: Package(s) not found: {}\n", name),
1,
)
}
};
let lower = name.to_lowercase();
let dist = entries.iter().find(|e| {
e.is_dir
&& e.name.ends_with(".dist-info")
&& e.name.to_lowercase().starts_with(&format!("{}-", lower))
});
match dist {
None => CommandOutput::error(format!("WARNING: Package(s) not found: {}\n", name), 1),
Some(d) => {
let md = self
.vfs
.read_to_string(&format!("{}/{}/METADATA", site_dir, d.name), &self.cwd)
.unwrap_or_default();
let mut out = String::new();
for line in md.lines() {
if line.starts_with("Name:")
|| line.starts_with("Version:")
|| line.starts_with("Summary:")
|| line.starts_with("Home-page:")
|| line.starts_with("Author:")
|| line.starts_with("License:")
{
out.push_str(line);
out.push('\n');
}
}
if out.is_empty() {
out = format!("Name: {}\n", name);
}
CommandOutput::success(out + "\n")
}
}
}
pub fn cmd_pip_uninstall(&mut self, name: &str) -> CommandOutput {
let site_dir = "site-packages";
let entries = self.vfs.list_dir(site_dir, &self.cwd).unwrap_or_default();
let lower = name.to_lowercase();
let mut removed = false;
for e in &entries {
if e.is_dir
&& e.name.ends_with(".dist-info")
&& e.name.to_lowercase().starts_with(&format!("{}-", lower))
{
let _ = self
.vfs
.remove_dir_all(&format!("{}/{}", site_dir, e.name), &self.cwd);
removed = true;
}
}
for e in &entries {
let dir_match = e.is_dir && e.name.to_lowercase() == lower;
let file_match = !e.is_dir && e.name.to_lowercase() == format!("{}.py", lower);
if dir_match {
let _ = self
.vfs
.remove_dir_all(&format!("{}/{}", site_dir, e.name), &self.cwd);
removed = true;
} else if file_match {
let _ = self
.vfs
.remove_file(&format!("{}/{}", site_dir, e.name), &self.cwd);
removed = true;
}
}
if removed {
CommandOutput::success(format!("Successfully uninstalled {}\n", name))
} else {
CommandOutput::error(
format!("WARNING: Skipping {} as it is not installed.\n", name),
1,
)
}
}
fn cmd_pip_list(&self) -> CommandOutput {
let site_dir = "site-packages";
let entries = match self.vfs.list_dir(site_dir, &self.cwd) {
Ok(e) => e,
Err(_) => return CommandOutput::success("(no packages installed)\n".to_string()),
};
let mut installed: std::collections::HashSet<String> = std::collections::HashSet::new();
for entry in &entries {
if entry.name == "__pycache__" || entry.name == "site-packages" {
continue;
}
if entry.is_dir {
if entry.name.ends_with(".dist-info") {
let metadata_path = format!("{}/{}/METADATA", site_dir, entry.name);
let pkg_name = self
.vfs
.read_to_string(&metadata_path, &self.cwd)
.ok()
.and_then(|c| extract_name_from_metadata(&c))
.unwrap_or_else(|| strip_dist_info_version(&entry.name));
if !pkg_name.is_empty() {
installed.insert(pkg_name);
}
} else {
installed.insert(entry.name.clone());
}
} else if entry.name.ends_with(".py") {
let module_name = entry.name.trim_end_matches(".py");
let has_dist_info = entries.iter().any(|e| {
e.is_dir
&& e.name.ends_with(".dist-info")
&& e.name.starts_with(&format!("{}-", module_name))
});
if has_dist_info {
installed.insert(module_name.to_string());
}
}
}
if installed.is_empty() {
return CommandOutput::success("(no packages installed)\n".to_string());
}
let mut names: Vec<&String> = installed.iter().collect();
names.sort();
let mut output = String::new();
for name in names {
output.push_str(&format!("{}\n", name));
}
CommandOutput::success(output)
}
}
fn pypi_base() -> String {
std::env::var("FASTSHELL_PYPI_INDEX")
.ok()
.filter(|s| !s.trim().is_empty())
.unwrap_or_else(|| "https://pypi.org".to_string())
}
fn pip_http_get(url: &str, what: &str) -> Result<Vec<u8>, String> {
use crate::shell::commands::curl::{http_request_ex, HttpConfig};
let mut last = String::new();
for attempt in 0..3u32 {
let cfg = HttpConfig {
method: "GET".to_string(),
url: url.to_string(),
follow_redirects: true,
request_timeout_secs: 60.0,
connect_timeout_secs: 15.0,
..Default::default()
};
match http_request_ex(&cfg) {
Ok(r) => return Ok(r.body),
Err(e) => last = e.message.clone(),
}
std::thread::sleep(std::time::Duration::from_millis(
300 * u64::from(attempt + 1),
));
}
Err(format!("{what}: {last}"))
}
fn install_package(
pkg: &str,
cache_dir: &std::path::Path,
site_dir: &str,
vfs: &crate::vfs::Vfs,
cwd: &str,
) -> Result<String, String> {
let (pkg_name, version) = parse_pkg_spec(pkg);
let info = fetch_pypi_info(pkg_name)?;
let wheel_file = find_best_wheel(&info, version).ok_or_else(|| {
if let Some(v) = version {
format!("no py3-none-any.whl found for {} version {}", pkg_name, v)
} else {
format!(
"no py3-none-any.whl found for {} (may require C extensions or single-file wheel)",
pkg_name
)
}
})?;
let wheel_url = &wheel_file.url;
let wheel_name = wheel_url.rsplit('/').next().unwrap_or(pkg_name);
let cached = cache_dir.join(wheel_name);
let wheel_data = if cached.exists() {
let mut data = Vec::new();
std::io::Read::read_to_end(
&mut std::fs::File::open(&cached).map_err(|e| e.to_string())?,
&mut data,
)
.map_err(|e| e.to_string())?;
data
} else {
let data = pip_http_get(wheel_url, "download failed")?;
if let Some(parent) = cached.parent() {
let _ = std::fs::create_dir_all(parent);
let _ = std::fs::write(&cached, &data);
}
data
};
validate_pure_python_wheel(&wheel_data, pkg_name)?;
extract_wheel(&wheel_data, site_dir, vfs, cwd)?;
Ok(String::new())
}
struct WheelFile {
filename: String,
url: String,
}
fn parse_pkg_spec(pkg: &str) -> (&str, Option<&str>) {
if let Some(pos) = pkg.find("==") {
(&pkg[..pos], Some(&pkg[pos + 2..]))
} else {
(pkg, None)
}
}
fn extract_name_from_metadata(content: &str) -> Option<String> {
for line in content.lines() {
if let Some(v) = line.strip_prefix("Name:") {
let name = v.trim();
if !name.is_empty() {
return Some(name.to_string());
}
}
}
None
}
fn strip_dist_info_version(dist_info: &str) -> String {
let base = dist_info.trim_end_matches(".dist-info");
for (i, ch) in base.char_indices().rev() {
if ch == '-' {
let rest = &base[i + 1..];
if rest.chars().next().map_or(false, |c| c.is_ascii_digit()) {
return base[..i].to_string();
}
}
}
base.to_string()
}
fn find_best_wheel<'a>(info: &'a [WheelFile], version: Option<&str>) -> Option<&'a WheelFile> {
let candidates: Vec<&WheelFile> = info
.iter()
.filter(|f| {
let name = &f.filename;
name.contains("-none-any.whl")
})
.collect();
if let Some(ver) = version {
candidates
.into_iter()
.rev()
.find(|f| f.filename.contains(ver))
} else {
candidates.into_iter().last()
}
}
fn fetch_pypi_info(pkg: &str) -> Result<Vec<WheelFile>, String> {
let url = format!("{}/pypi/{}/json", pypi_base().trim_end_matches('/'), pkg);
let body = pip_http_get(&url, "PyPI query failed")?;
let json: serde_json::Value =
serde_json::from_slice(&body).map_err(|e| format!("PyPI JSON parse error: {}", e))?;
let mut result = Vec::new();
let releases = json["releases"].as_object().ok_or("no releases field")?;
let mut versions: Vec<&String> = releases.keys().collect();
versions.sort_by_key(|v| parse_version(v));
for ver in &versions {
if let Some(files) = releases[*ver].as_array() {
for file in files {
let filename = file["filename"].as_str().unwrap_or("");
let url = file["url"].as_str().unwrap_or("");
if !filename.is_empty() && !url.is_empty() {
result.push(WheelFile {
filename: filename.to_string(),
url: url.to_string(),
});
}
}
}
}
if result.is_empty() {
return Err(format!("no releases found for {}", pkg));
}
Ok(result)
}
fn parse_version(v: &str) -> Vec<i64> {
v.split(|c: char| !c.is_ascii_digit())
.filter(|s| !s.is_empty())
.filter_map(|s| s.parse::<i64>().ok())
.collect()
}
fn validate_pure_python_wheel(data: &[u8], pkg: &str) -> Result<(), String> {
let cursor = Cursor::new(data);
let mut archive = zip::ZipArchive::new(cursor).map_err(|e| format!("bad wheel file: {}", e))?;
for i in 0..archive.len() {
let entry = archive
.by_index(i)
.map_err(|e| format!("read wheel: {}", e))?;
let name = entry.name();
if name.ends_with(".so") || name.ends_with(".pyd") {
return Err(format!(
"{} contains compiled C extension ({}) — cannot install on RustPython. Only pure-Python packages (py3-none-any.whl) are supported.",
pkg, name
));
}
}
Ok(())
}
fn extract_wheel(
data: &[u8],
site_dir: &str,
vfs: &crate::vfs::Vfs,
cwd: &str,
) -> Result<(), String> {
let cursor = Cursor::new(data);
let mut archive = zip::ZipArchive::new(cursor).map_err(|e| format!("bad wheel file: {}", e))?;
let (is_single_file, pkg_root) = classify_package(&mut archive)?;
if is_single_file {
extract_single_file_wheel(&mut archive, &pkg_root, site_dir, vfs, cwd)?;
} else {
let dest_dir = format!("{}/{}", site_dir, pkg_root);
extract_directory_wheel(&mut archive, &pkg_root, &dest_dir, site_dir, vfs, cwd)?;
}
Ok(())
}
fn classify_package<R: std::io::Read + std::io::Seek>(
archive: &mut zip::ZipArchive<R>,
) -> Result<(bool, String), String> {
let mut pkg_root = String::new();
let mut has_dir_entry = false;
for i in 0..archive.len() {
let entry = archive
.by_index(i)
.map_err(|e| format!("read wheel: {}", e))?;
let name = entry.name().to_string();
if name.contains(".dist-info/") || name.contains(".data/") {
continue;
}
let top = name.split('/').next().unwrap_or("");
if top.is_empty() || top.ends_with(".dist-info") || top.ends_with(".data") {
continue;
}
if pkg_root.is_empty() {
pkg_root = top.to_string();
}
if name.contains('/') && name != format!("{}/", pkg_root) {
has_dir_entry = true;
}
}
if pkg_root.is_empty() {
return Err("wheel contains no installable files".to_string());
}
let is_single_file = !has_dir_entry && pkg_root.ends_with(".py");
Ok((is_single_file, pkg_root))
}
fn extract_single_file_wheel<R: std::io::Read + std::io::Seek>(
archive: &mut zip::ZipArchive<R>,
pkg_root: &str,
site_dir: &str,
vfs: &crate::vfs::Vfs,
cwd: &str,
) -> Result<(), String> {
let _ = vfs.create_dir_all(site_dir, cwd);
for i in 0..archive.len() {
let mut entry = archive
.by_index(i)
.map_err(|e| format!("read wheel: {}", e))?;
let name = entry.name().to_string();
if entry.is_dir() {
continue;
}
if name.contains(".dist-info/") {
let out_path = format!("{}/{}", site_dir, name);
let mut content = Vec::new();
std::io::Read::read_to_end(&mut entry, &mut content)
.map_err(|e| format!("read wheel entry {}: {}", name, e))?;
if let Some(parent) = std::path::Path::new(&out_path).parent() {
let _ = vfs.create_dir_all(&parent.to_string_lossy(), cwd);
}
vfs.write_bytes(&out_path, cwd, &content)
.map_err(|e| format!("write {}: {}", out_path, e))?;
continue;
}
if name.contains(".data/") {
continue;
}
let out_path = format!("{}/{}", site_dir, pkg_root);
let mut content = Vec::new();
std::io::Read::read_to_end(&mut entry, &mut content)
.map_err(|e| format!("read wheel entry {}: {}", name, e))?;
vfs.write_bytes(&out_path, cwd, &content)
.map_err(|e| format!("write {}: {}", out_path, e))?;
}
Ok(())
}
fn extract_directory_wheel<R: std::io::Read + std::io::Seek>(
archive: &mut zip::ZipArchive<R>,
pkg_dir: &str,
dest_dir: &str,
site_dir: &str,
vfs: &crate::vfs::Vfs,
cwd: &str,
) -> Result<(), String> {
let pkg_prefix = format!("{}/", pkg_dir);
for i in 0..archive.len() {
let mut entry = archive
.by_index(i)
.map_err(|e| format!("read wheel: {}", e))?;
let name = entry.name().to_string();
if name.contains(".data/") {
continue;
}
let is_dist_info = name.contains(".dist-info/");
let relative = if name.starts_with(&pkg_prefix) && pkg_prefix.len() > 0 {
&name[pkg_prefix.len()..]
} else if name == pkg_dir || name == format!("{}/", pkg_dir) {
continue;
} else {
&name
};
let out_path = if is_dist_info {
format!("{}/{}", site_dir, name)
} else {
format!("{}/{}", dest_dir, relative)
};
if entry.is_dir() {
let _ = vfs.create_dir(&out_path, cwd);
continue;
}
let mut content = Vec::new();
std::io::Read::read_to_end(&mut entry, &mut content)
.map_err(|e| format!("read wheel entry {}: {}", name, e))?;
if let Some(parent) = std::path::Path::new(&out_path).parent() {
let parent_str = parent.to_string_lossy();
if !parent_str.is_empty() {
let _ = vfs.create_dir_all(&parent_str, cwd);
}
}
vfs.write_bytes(&out_path, cwd, &content)
.map_err(|e| format!("write {}: {}", out_path, e))?;
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_version() {
assert!(parse_version("1.0") > parse_version("0.9"));
assert!(parse_version("2.31.0") > parse_version("2.3.0"));
assert!(parse_version("2.10") > parse_version("2.9"));
}
#[test]
fn test_parse_pkg_spec_without_version() {
let (name, ver) = parse_pkg_spec("six");
assert_eq!(name, "six");
assert_eq!(ver, None);
}
#[test]
fn test_parse_pkg_spec_with_version() {
let (name, ver) = parse_pkg_spec("requests==2.31.0");
assert_eq!(name, "requests");
assert_eq!(ver, Some("2.31.0"));
}
#[test]
fn test_parse_pkg_spec_with_version_in_name() {
let (name, ver) = parse_pkg_spec("python-dateutil==2.8.2");
assert_eq!(name, "python-dateutil");
assert_eq!(ver, Some("2.8.2"));
}
#[test]
fn test_find_best_wheel_version_match() {
let info = vec![
WheelFile {
filename: "six-1.16.0-py2.py3-none-any.whl".into(),
url: "https://example.com/six-1.16.0-py2.py3-none-any.whl".into(),
},
WheelFile {
filename: "six-1.17.0-py2.py3-none-any.whl".into(),
url: "https://example.com/six-1.17.0-py2.py3-none-any.whl".into(),
},
];
let w = find_best_wheel(&info, Some("1.16.0")).unwrap();
assert!(w.filename.contains("1.16.0"));
let w = find_best_wheel(&info, None).unwrap();
assert!(w.filename.contains("1.17.0"));
}
#[test]
fn test_find_best_wheel_py2_py3_matched() {
let info = vec![WheelFile {
filename: "six-1.17.0-py2.py3-none-any.whl".into(),
url: "https://example.com/six-1.17.0.whl".into(),
}];
let w = find_best_wheel(&info, None).unwrap();
assert!(w.filename.contains("six"));
}
#[test]
fn test_find_best_wheel_rejects_cp_specific() {
let info = vec![WheelFile {
filename: "numpy-1.26.0-cp312-cp312-manylinux.whl".into(),
url: "https://example.com/numpy.whl".into(),
}];
assert!(find_best_wheel(&info, None).is_none());
}
#[test]
fn test_classify_single_file_package() {
let data = make_test_wheel(&[
("six.py", b"def foo(): pass\n"),
(
"six-1.17.0.dist-info/METADATA",
b"Name: six\nVersion: 1.17.0\n",
),
]);
let cursor = Cursor::new(data);
let mut archive = zip::ZipArchive::new(cursor).unwrap();
let (is_single, root) = classify_package(&mut archive).unwrap();
assert!(is_single, "six should be classified as single-file");
assert_eq!(root, "six.py");
}
#[test]
fn test_classify_directory_package() {
let data = make_test_wheel(&[
("requests/__init__.py", b"from .api import get\n"),
("requests/api.py", b"def get(): pass\n"),
("requests-2.31.0.dist-info/METADATA", b"Name: requests\n"),
]);
let cursor = Cursor::new(data);
let mut archive = zip::ZipArchive::new(cursor).unwrap();
let (is_single, root) = classify_package(&mut archive).unwrap();
assert!(!is_single, "requests should be classified as directory");
assert_eq!(root, "requests");
}
#[test]
fn test_extract_single_file_wheel_vfs() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_extract_single_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let data = make_test_wheel(&[
("six.py", b"def foo():\n return 42\n"),
(
"six-1.17.0.dist-info/METADATA",
b"Name: six\nVersion: 1.17.0\n",
),
]);
let cursor = Cursor::new(data);
let mut archive = zip::ZipArchive::new(cursor).unwrap();
let (is_single, root) = classify_package(&mut archive).unwrap();
assert!(is_single);
extract_single_file_wheel(&mut archive, &root, "site-packages", &vfs, "/").unwrap();
let entries = vfs.list_dir("site-packages", "/").unwrap();
let has_six_py = entries.iter().any(|e| e.name == "six.py");
assert!(has_six_py, "six.py should be extracted");
let has_dist_info = entries
.iter()
.any(|e| e.name == "six-1.17.0.dist-info" && e.is_dir);
assert!(has_dist_info, "six-1.17.0.dist-info should be extracted");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_extract_directory_wheel_vfs() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_extract_dir_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let data = make_test_wheel(&[
("requests/__init__.py", b"from .api import get\n"),
("requests/api.py", b"def get(): pass\n"),
("requests/sub/__init__.py", b"x=1\n"),
("requests-2.31.0.dist-info/METADATA", b"Name: requests\n"),
]);
let mut cursor = Cursor::new(data);
let mut archive = zip::ZipArchive::new(cursor).unwrap();
extract_directory_wheel(
&mut archive,
"requests",
"site-packages/requests",
"site-packages",
&vfs,
"/",
)
.unwrap();
let sub_entries = vfs.list_dir("site-packages/requests", "/").unwrap();
assert!(sub_entries.iter().any(|e| e.name == "__init__.py"));
assert!(sub_entries.iter().any(|e| e.name == "api.py"));
let top_entries = vfs.list_dir("site-packages", "/").unwrap();
assert!(
top_entries
.iter()
.any(|e| e.name == "requests-2.31.0.dist-info" && e.is_dir),
"requests-2.31.0.dist-info should be at site-packages top level"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_extract_wheel_single_file_integration() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_integrate_single_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let mut cursor = Cursor::new(Vec::new());
let mut writer = zip::ZipWriter::new(cursor);
let opts =
zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Deflated);
writer.start_file("six.py", opts).unwrap();
std::io::Write::write_all(&mut writer, b"__version__ = '1.17.0'\n").unwrap();
writer
.start_file("six-1.17.0.dist-info/METADATA", opts)
.unwrap();
std::io::Write::write_all(&mut writer, b"Name: six\n").unwrap();
let data = writer.finish().unwrap().into_inner();
extract_wheel(&data, "site-packages", &vfs, "/").unwrap();
let entries = vfs.list_dir("site-packages", "/").unwrap();
assert!(
entries.iter().any(|e| e.name == "six.py"),
"six.py should be there"
);
assert!(
entries
.iter()
.any(|e| e.name == "six-1.17.0.dist-info" && e.is_dir),
"versioned dist-info should be there"
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_extract_wheel_directory_integration() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_integrate_dir_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let mut cursor = Cursor::new(Vec::new());
let mut writer = zip::ZipWriter::new(cursor);
let opts =
zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Deflated);
writer.start_file("colorama/__init__.py", opts).unwrap();
std::io::Write::write_all(&mut writer, b"from .ansi import AnsiCodes\n").unwrap();
writer
.start_file("colorama-0.4.6.dist-info/METADATA", opts)
.unwrap();
std::io::Write::write_all(&mut writer, b"Name: colorama\n").unwrap();
let data = writer.finish().unwrap().into_inner();
extract_wheel(&data, "site-packages", &vfs, "/").unwrap();
let entries = vfs.list_dir("site-packages", "/").unwrap();
let pkg = entries
.iter()
.find(|e| e.name == "colorama" && e.is_dir)
.expect("colorama directory should exist");
assert!(pkg.is_dir);
let sub = vfs.list_dir("site-packages/colorama", "/").unwrap();
assert!(sub.iter().any(|e| e.name == "__init__.py"));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_extract_wheel_dist_name_differs_from_module() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_dist_diff_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let mut cursor = Cursor::new(Vec::new());
let mut writer = zip::ZipWriter::new(cursor);
let opts =
zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Deflated);
writer
.start_file("charset_normalizer/__init__.py", opts)
.unwrap();
std::io::Write::write_all(&mut writer, b"__version__ = '3.5.0'\n").unwrap();
writer
.start_file("charset_normalizer/api.py", opts)
.unwrap();
std::io::Write::write_all(&mut writer, b"def from_bytes(x): pass\n").unwrap();
writer
.start_file("charset_normalizer-3.5.0.dist-info/METADATA", opts)
.unwrap();
std::io::Write::write_all(&mut writer, b"Name: charset-normalizer\n").unwrap();
let data = writer.finish().unwrap().into_inner();
extract_wheel(&data, "site-packages", &vfs, "/").unwrap();
let entries = vfs.list_dir("site-packages", "/").unwrap();
assert!(
entries
.iter()
.any(|e| e.name == "charset_normalizer" && e.is_dir),
"module dir should use underscore name, got: {:?}",
entries.iter().map(|e| e.name.as_str()).collect::<Vec<_>>()
);
assert!(
!entries.iter().any(|e| e.name == "charset-normalizer"),
"hyphenated dist name should NOT be used as dir"
);
let sub = vfs
.list_dir("site-packages/charset_normalizer", "/")
.unwrap();
assert!(sub.iter().any(|e| e.name == "__init__.py"));
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_pip_list_with_installed_packages() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_list_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let shell = Shell::new(vfs);
let out = shell.cmd_pip_list();
assert!(out.stdout.contains("(no packages installed)"));
shell
.vfs
.create_dir_all("site-packages/colorama", "/")
.unwrap();
shell
.vfs
.write_bytes("site-packages/colorama/__init__.py", "/", b"x=1")
.unwrap();
let out = shell.cmd_pip_list();
assert!(out.stdout.contains("colorama"));
assert!(!out.stdout.contains("(no packages installed)"));
assert_eq!(out.exit_code, 0);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_pip_list_with_single_file_module() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_list_single_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let shell = Shell::new(vfs);
shell.vfs.create_dir_all("site-packages", "/").unwrap();
shell
.vfs
.write_bytes("site-packages/six.py", "/", b"x=1")
.unwrap();
shell
.vfs
.create_dir_all("site-packages/six-1.17.0.dist-info", "/")
.unwrap();
shell
.vfs
.write_bytes(
"site-packages/six-1.17.0.dist-info/METADATA",
"/",
b"Name: six\nVersion: 1.17.0\n",
)
.unwrap();
let out = shell.cmd_pip_list();
assert!(
out.stdout.contains("six"),
"pip list should include single-file module: {}",
out.stdout
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_pip_list_excludes_pycache() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join(format!(
"fastshell_pip_list_pycache_{}_{}",
std::process::id(),
uuid::Uuid::new_v4().simple()
));
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir.clone()).unwrap();
let shell = Shell::new(vfs);
shell
.vfs
.create_dir_all("site-packages/colorama", "/")
.unwrap();
shell
.vfs
.create_dir_all("site-packages/__pycache__", "/")
.unwrap();
shell
.vfs
.write_bytes("site-packages/colorama/__init__.py", "/", b"x=1")
.unwrap();
let out = shell.cmd_pip_list();
assert!(out.stdout.contains("colorama"), "colorama should be listed");
assert!(
!out.stdout.contains("__pycache__"),
"__pycache__ should be excluded, got: {}",
out.stdout
);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn test_validate_no_c_extensions() {
let data = make_test_wheel(&[("test/__init__.py", b"x=1"), ("test/module.py", b"y=2")]);
assert!(validate_pure_python_wheel(&data, "test").is_ok());
}
#[test]
fn test_validate_rejects_so() {
let data = make_test_wheel(&[
("test/__init__.py", b"x=1"),
("test/_speedups.so", b"\x7fELF"),
]);
assert!(validate_pure_python_wheel(&data, "test").is_err());
}
fn make_test_wheel(files: &[(&str, &[u8])]) -> Vec<u8> {
let cursor = Cursor::new(Vec::new());
let mut writer = zip::ZipWriter::new(cursor);
let options =
zip::write::FileOptions::default().compression_method(zip::CompressionMethod::Deflated);
for (name, data) in files {
writer.start_file(*name, options).unwrap();
std::io::Write::write_all(&mut writer, data).unwrap();
}
writer.finish().unwrap().into_inner()
}
#[test]
fn test_pip_install_help() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join("fastshell_pip_test_help");
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir).unwrap();
let shell = Shell::new(vfs);
let out = shell.cmd_pip_install(&["-h"]);
assert_eq!(out.exit_code, 0);
assert!(out.stdout.contains("pip install"));
}
#[test]
fn test_pip_install_help_long() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join("fastshell_pip_test_help2");
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir).unwrap();
let shell = Shell::new(vfs);
let out = shell.cmd_pip_install(&["--help"]);
assert_eq!(out.exit_code, 0);
}
#[test]
fn test_pip_install_no_args_error() {
use crate::vfs::Vfs;
let dir = std::env::temp_dir().join("fastshell_pip_test_noargs");
let _ = std::fs::remove_dir_all(&dir);
let vfs = Vfs::new(dir).unwrap();
let shell = Shell::new(vfs);
let out = shell.cmd_pip_install(&[]);
assert_eq!(out.exit_code, 1);
}
}