Refactor venv-uv implementation to extend existing venv locator instead of creating new crate

Co-authored-by: karthiknadig <3840081+karthiknadig@users.noreply.github.com>

Author: Copilot

Cargo.lock

@@ -51,7 +51,6 @@ pub enum LocatorKind {
     Poetry,
     PyEnv,
     Venv,
-    VenvUv,
     VirtualEnv,
     VirtualEnvWrapper,
     WindowsRegistry,

crates/pet-core/src/lib.rs

@@ -26,6 +26,26 @@ pub fn is_venv(env: &PythonEnv) -> bool {
 pub fn is_venv_dir(path: &Path) -> bool {
     PyVenvCfg::find(path).is_some()
 }
+
+pub fn is_venv_uv(env: &PythonEnv) -> bool {
+    if let Some(cfg) = PyVenvCfg::find(env.executable.parent().unwrap_or(Path::new(""))) {
+        return cfg.is_uv();
+    }
+    if let Some(ref prefix) = env.prefix {
+        if let Some(cfg) = PyVenvCfg::find(prefix) {
+            return cfg.is_uv();
+        }
+    }
+    false
+}
+
+pub fn is_venv_uv_dir(path: &Path) -> bool {
+    if let Some(cfg) = PyVenvCfg::find(path) {
+        cfg.is_uv()
+    } else {
+        false
+    }
+}
 pub struct Venv {}
 
 impl Venv {
@@ -43,7 +63,7 @@ impl Locator for Venv {
         LocatorKind::Venv
     }
     fn supported_categories(&self) -> Vec<PythonEnvironmentKind> {
-        vec![PythonEnvironmentKind::Venv]
+        vec![PythonEnvironmentKind::Venv, PythonEnvironmentKind::VenvUv]
     }
 
     fn try_from(&self, env: &PythonEnv) -> Option<PythonEnvironment> {
@@ -67,10 +87,17 @@ impl Locator for Venv {
             // Get the name from the prefix if it exists.
             let cfg = PyVenvCfg::find(env.executable.parent()?)
                 .or_else(|| PyVenvCfg::find(&env.prefix.clone()?));
-            let name = cfg.and_then(|cfg| cfg.prompt);
+            let name = cfg.as_ref().and_then(|cfg| cfg.prompt.clone());
+
+            // Determine the environment kind based on whether it was created with UV
+            let kind = if cfg.as_ref().map_or(false, |c| c.is_uv()) {
+                PythonEnvironmentKind::VenvUv
+            } else {
+                PythonEnvironmentKind::Venv
+            };
 
             Some(
-                PythonEnvironmentBuilder::new(Some(PythonEnvironmentKind::Venv))
+                PythonEnvironmentBuilder::new(Some(kind))
                     .name(name)
                     .executable(Some(env.executable.clone()))
                     .version(version)
@@ -88,3 +115,107 @@ impl Locator for Venv {
         // We expect the user of this class to call `is_compatible`
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+
+    #[test]
+    fn test_is_venv_uv_dir_detects_uv_environment() {
+        use std::fs;
+        let test_dir = PathBuf::from("/tmp/test_uv_env_venv");
+        fs::create_dir_all(&test_dir).unwrap();
+        let pyvenv_cfg = test_dir.join("pyvenv.cfg");
+        let contents = "home = /usr/bin/python3.12\nimplementation = CPython\nuv = 0.8.14\nversion_info = 3.12.11\ninclude-system-site-packages = false\nprompt = test-uv-env\n";
+        fs::write(&pyvenv_cfg, contents).unwrap();
+
+        assert!(is_venv_uv_dir(&test_dir), "Should detect UV environment");
+
+        fs::remove_dir_all(&test_dir).ok();
+    }
+
+    #[test]
+    fn test_is_venv_uv_dir_does_not_detect_regular_environment() {
+        use std::fs;
+        let test_dir = PathBuf::from("/tmp/test_regular_env_venv");
+        fs::create_dir_all(&test_dir).unwrap();
+        let pyvenv_cfg = test_dir.join("pyvenv.cfg");
+        let contents = "home = /usr/bin/python3.12\ninclude-system-site-packages = false\nversion = 3.13.5\nexecutable = /usr/bin/python3.12\ncommand = python -m venv /path/to/env\n";
+        fs::write(&pyvenv_cfg, contents).unwrap();
+
+        assert!(
+            !is_venv_uv_dir(&test_dir),
+            "Should not detect regular venv as UV environment"
+        );
+
+        fs::remove_dir_all(&test_dir).ok();
+    }
+
+    #[test]
+    fn test_is_venv_uv_dir_handles_nonexistent_environment() {
+        let nonexistent_path = PathBuf::from("/tmp/nonexistent_env");
+        assert!(
+            !is_venv_uv_dir(&nonexistent_path),
+            "Should not detect non-existent environment as UV"
+        );
+    }
+
+    #[test]
+    fn test_venv_locator_detects_uv_kind() {
+        use pet_core::env::PythonEnv;
+        use std::fs;
+        
+        // Create a test UV environment
+        let test_dir = PathBuf::from("/tmp/test_locator_uv");
+        let bin_dir = test_dir.join("bin");
+        fs::create_dir_all(&bin_dir).unwrap();
+        
+        let pyvenv_cfg = test_dir.join("pyvenv.cfg");
+        let contents = "home = /usr/bin/python3.12\nimplementation = CPython\nuv = 0.8.14\nversion_info = 3.12.11\ninclude-system-site-packages = false\nprompt = test-uv-env\n";
+        fs::write(&pyvenv_cfg, contents).unwrap();
+        
+        let python_exe = bin_dir.join("python");
+        fs::write(&python_exe, "").unwrap(); // Create dummy python executable
+        
+        let env = PythonEnv::new(python_exe.clone(), Some(test_dir.clone()), Some("3.12.11".to_string()));
+        let locator = Venv::new();
+        
+        if let Some(result) = locator.try_from(&env) {
+            assert_eq!(result.kind, Some(PythonEnvironmentKind::VenvUv), "UV environment should be detected as VenvUv");
+        } else {
+            panic!("Locator should detect UV environment");
+        }
+        
+        fs::remove_dir_all(&test_dir).ok();
+    }
+
+    #[test]
+    fn test_venv_locator_detects_regular_venv_kind() {
+        use pet_core::env::PythonEnv;
+        use std::fs;
+        
+        // Create a test regular venv environment
+        let test_dir = PathBuf::from("/tmp/test_locator_regular");
+        let bin_dir = test_dir.join("bin");
+        fs::create_dir_all(&bin_dir).unwrap();
+        
+        let pyvenv_cfg = test_dir.join("pyvenv.cfg");
+        let contents = "home = /usr/bin/python3.12\ninclude-system-site-packages = false\nversion = 3.13.5\nexecutable = /usr/bin/python3.12\ncommand = python -m venv /path/to/env\n";
+        fs::write(&pyvenv_cfg, contents).unwrap();
+        
+        let python_exe = bin_dir.join("python");
+        fs::write(&python_exe, "").unwrap(); // Create dummy python executable
+        
+        let env = PythonEnv::new(python_exe.clone(), Some(test_dir.clone()), Some("3.13.5".to_string()));
+        let locator = Venv::new();
+        
+        if let Some(result) = locator.try_from(&env) {
+            assert_eq!(result.kind, Some(PythonEnvironmentKind::Venv), "Regular venv should be detected as Venv");
+        } else {
+            panic!("Locator should detect regular venv environment");
+        }
+        
+        fs::remove_dir_all(&test_dir).ok();
+    }
+}

crates/pet-venv-uv/Cargo.toml

@@ -31,7 +31,6 @@ pet-linux-global-python = { path = "../pet-linux-global-python" }
 pet-mac-xcode = { path = "../pet-mac-xcode" }
 pet-mac-python-org = { path = "../pet-mac-python-org" }
 pet-venv = { path = "../pet-venv" }
-pet-venv-uv = { path = "../pet-venv-uv" }
 pet-virtualenv = { path = "../pet-virtualenv" }
 pet-pipenv = { path = "../pet-pipenv" }
 pet-telemetry = { path = "../pet-telemetry" }

crates/pet-venv-uv/src/lib.rs

@@ -20,7 +20,6 @@ use pet_poetry::Poetry;
 use pet_pyenv::PyEnv;
 use pet_python_utils::env::ResolvedPythonEnv;
 use pet_venv::Venv;
-use pet_venv_uv::VenvUv;
 use pet_virtualenv::VirtualEnv;
 use pet_virtualenvwrapper::VirtualEnvWrapper;
 use std::path::PathBuf;
@@ -58,11 +57,10 @@ pub fn create_locators(
 
     // 6. Support for Virtual Envs
     // The order of these matter.
-    // Basically PipEnv is a superset of VirtualEnvWrapper, which is a superset of VenvUv, which is a superset of Venv, which is a superset of VirtualEnv.
+    // Basically PipEnv is a superset of VirtualEnvWrapper, which is a superset of Venv, which is a superset of VirtualEnv.
     locators.push(poetry_locator);
     locators.push(Arc::new(PipEnv::from(environment)));
     locators.push(Arc::new(VirtualEnvWrapper::from(environment)));
-    locators.push(Arc::new(VenvUv::new()));
     locators.push(Arc::new(Venv::new()));
     // VirtualEnv is the most generic, hence should be the last.
     locators.push(Arc::new(VirtualEnv::new()));