Fix PET failures with pyenv shims by detecting and skipping them

Co-authored-by: DonJayamanne <1948812+DonJayamanne@users.noreply.github.com>

Author: Copilot

Cargo.lock

@@ -25,3 +25,6 @@ ci-homebrew-container = []
 ci-poetry-global = []
 ci-poetry-project = []
 ci-poetry-custom = []
+
+[dev-dependencies]
+tempfile = "3.8"

crates/pet-python-utils/Cargo.toml

@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use pet_python_utils::is_pyenv_shim;
+use std::path::PathBuf;
+
+fn main() {
+    env_logger::init();
+    
+    let shim_path = PathBuf::from("/tmp/fake_pyenv/shims/python3.10");
+    println!("Testing path: {:?}", shim_path);
+    println!("Is pyenv shim: {}", is_pyenv_shim(&shim_path));
+    
+    let regular_path = PathBuf::from("/usr/bin/python3");
+    println!("Testing path: {:?}", regular_path);
+    println!("Is regular path shim: {}", is_pyenv_shim(&regular_path));
+}

crates/pet-python-utils/examples/test_shim_detection.rs

@@ -5,6 +5,7 @@ use log::{error, trace};
 use pet_core::{arch::Architecture, env::PythonEnv, python_environment::PythonEnvironment};
 use serde::{Deserialize, Serialize};
 use std::{
+    fs,
     path::{Path, PathBuf},
     time::SystemTime,
 };
@@ -88,6 +89,12 @@ impl ResolvedPythonEnv {
 }
 
 fn get_interpreter_details(executable: &Path) -> Option<ResolvedPythonEnv> {
+    // Skip pyenv shims as they don't work when executed directly
+    if is_pyenv_shim(executable) {
+        trace!("Skipping pyenv shim: {:?}", executable);
+        return None;
+    }
+
     // Spawn the python exe and get the version, sys.prefix and sys.executable.
     let executable = executable.to_str()?;
     let start = SystemTime::now();
@@ -143,3 +150,25 @@ fn get_interpreter_details(executable: &Path) -> Option<ResolvedPythonEnv> {
         }
     }
 }
+
+/// Detect if an executable is a pyenv shim by checking if its path contains .pyenv/shims
+/// or by reading the file content to look for pyenv-specific patterns
+pub fn is_pyenv_shim(executable: &Path) -> bool {
+    // Check if the path contains .pyenv/shims
+    if let Some(path_str) = executable.to_str() {
+        if path_str.contains("/.pyenv/shims/") {
+            return true;
+        }
+    }
+
+    // Additionally, check if it's a shell script with pyenv content
+    if let Ok(content) = fs::read_to_string(executable) {
+        // Look for common pyenv shim patterns
+        if content.contains("PYENV_ROOT") && content.contains("pyenv") && content.contains("exec") {
+            trace!("Detected pyenv shim by content: {:?}", executable);
+            return true;
+        }
+    }
+
+    false
+}

crates/pet-python-utils/src/env.rs

@@ -8,3 +8,5 @@ pub mod fs_cache;
 mod headers;
 pub mod platform_dirs;
 pub mod version;
+
+pub use env::is_pyenv_shim;

crates/pet-python-utils/src/lib.rs

@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use std::fs;
+use std::io::Write;
+use std::path::PathBuf;
+use tempfile::NamedTempFile;
+
+use pet_python_utils::{env::ResolvedPythonEnv, is_pyenv_shim};
+
+#[test]
+fn test_pyenv_shim_detection_by_path() {
+    // Test path-based detection
+    let shim_path = PathBuf::from("/home/user/.pyenv/shims/python3.10");
+    assert!(is_pyenv_shim(&shim_path));
+    
+    // Test that regular paths are not detected as shims
+    let regular_path = PathBuf::from("/usr/bin/python3");
+    assert!(!is_pyenv_shim(&regular_path));
+}
+
+#[test]
+fn test_pyenv_shim_detection_by_content() {
+    // Create a temporary file with pyenv shim content
+    let mut shim_file = NamedTempFile::new().unwrap();
+    let shim_content = r#"#!/usr/bin/env bash
+set -e
+[ -n "$PYENV_DEBUG" ] && set -x
+
+program="${0##*/}"
+
+export PYENV_ROOT="/home/user/.pyenv"
+exec "/home/user/.pyenv/libexec/pyenv" exec "$program" "$@"
+"#;
+    shim_file.write_all(shim_content.as_bytes()).unwrap();
+    
+    // Make it executable
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut perms = fs::metadata(shim_file.path()).unwrap().permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(shim_file.path(), perms).unwrap();
+    }
+    
+    // Test that this is detected as a pyenv shim
+    assert!(is_pyenv_shim(shim_file.path()));
+}
+
+#[test]
+fn test_pyenv_shim_resolve_returns_none() {
+    // Create a temporary file that looks like a pyenv shim
+    let mut shim_file = NamedTempFile::new().unwrap();
+    let shim_content = r#"#!/usr/bin/env bash
+export PYENV_ROOT="/home/user/.pyenv"
+exec "/home/user/.pyenv/libexec/pyenv" exec "$program" "$@"
+"#;
+    shim_file.write_all(shim_content.as_bytes()).unwrap();
+    
+    // Make it executable
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut perms = fs::metadata(shim_file.path()).unwrap().permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(shim_file.path(), perms).unwrap();
+    }
+    
+    // Test that we cannot resolve this pyenv shim
+    let result = ResolvedPythonEnv::from(shim_file.path());
+    
+    // The result should be None since pyenv shims should be skipped
+    assert!(result.is_none());
+}
+
+#[test]
+fn test_regular_script_not_detected_as_shim() {
+    // Create a regular script that shouldn't be detected as a pyenv shim
+    let mut script_file = NamedTempFile::new().unwrap();
+    let script_content = r#"#!/usr/bin/env bash
+echo "Hello World"
+python3 --version
+"#;
+    script_file.write_all(script_content.as_bytes()).unwrap();
+    
+    // Test that this is not detected as a pyenv shim
+    assert!(!is_pyenv_shim(script_file.path()));
+}