wovensnake 0.3.6

A high-performance Python package manager built with Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use std::error::Error;
use std::process::Command;

/// Validates that the system Python version matches the expected version.
/// Expected version should be in format "3.10", "3.11", etc.
/// If not found in system, it tries to use the managed Python versions.
pub async fn validate_python_version(expected: &str) -> Result<(), Box<dyn Error>> {
    find_python_executable(expected).await?;
    Ok(())
}

/// Finds a Python executable that matches the expected version.
/// Tries system PATH first, then managed versions.
pub async fn find_python_executable(expected: &str) -> Result<String, Box<dyn Error>> {
    // Try specific version first, then 'python', then 'python3'
    let commands = [
        format!("python{}", expected),
        "python".to_string(),
        "python3".to_string(),
    ];

    for cmd in commands {
        if let Ok(output) = Command::new(&cmd).arg("--version").output() {
            if output.status.success() {
                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();

                // Python 2.x and some 3.x versions print to stderr, others to stdout
                let version_str = if stdout.is_empty() { stderr } else { stdout };

                if version_str.contains(expected) || version_str.starts_with(&format!("Python {expected}")) {
                    return Ok(cmd);
                }
            }
        }
    }

    // Fallback to managed Python versions
    println!("Python {} not found in PATH. Checking managed versions...", expected);
    let managed_exe = crate::core::python_manager::ensure_python_version(expected).await?;
    Ok(managed_exe.to_string_lossy().to_string())
}

/// Attempts to detect the system's default Python version (major.minor).
pub fn get_system_python_version() -> Option<String> {
    let commands = ["python", "python3"];
    for cmd in commands {
        if let Ok(output) = Command::new(cmd).arg("--version").output() {
            if output.status.success() {
                let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
                let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
                let version_str = if stdout.is_empty() { stderr } else { stdout };

                // version_str is usually "Python 3.10.12"
                let parts: Vec<&str> = version_str.split_whitespace().collect();
                if parts.len() >= 2 {
                    let version_num = parts[1];
                    let version_parts: Vec<&str> = version_num.split('.').collect();
                    if version_parts.len() >= 2 {
                        return Some(format!("{}.{}", version_parts[0], version_parts[1]));
                    }
                }
            }
        }
    }
    None
}