fixes

Author: DonJayamanne

WIP.md

@@ -0,0 +1,24 @@
+# Tests
+* Vertualenv wrapper
+* Venvs
+- multiple venvs
+- create venv and verify version
+- change the env that ws used to create the venv
+(e.g. create venv A, then creaet venv B from A, then re-create A using another Python version)
+Verify we can still get the version of venv B without spawning Python.
+TODO: How to verify we did not spawn Python?
+- Verify we can get the version of venv without spawning Python in windows either
+* Venv and Conda
+- Conda should not be treated as venv
+- Create a venv and verify it is identified correctly
+- Create a conda with the exact same name and verify it is identified as a conda and not venv
+* Conda
+* Test each tool with PATH updated to include the env in the current PATH
+* Test by creating a symlink manually and storing it in PATH (or is this the same as previous test?)
+
+
+/// Verification 4 & 5:
+/// Similarly for each environment use resolve method and verify we get the exact same information.
+
+
+Ensure we create and initialize EnvironmentApi only once in one place and share that all over.

crates/pet/src/resolve.rs

@@ -3,9 +3,11 @@
 
 use std::{path::PathBuf, sync::Arc};
 
-use log::warn;
+use log::{trace, warn};
 use pet_core::{
-    arch::Architecture, os_environment::EnvironmentApi, python_environment::PythonEnvironment,
+    arch::Architecture,
+    os_environment::EnvironmentApi,
+    python_environment::{PythonEnvironment, PythonEnvironmentBuilder},
     Locator,
 };
 use pet_env_var_path::get_search_paths_from_env_variables;
@@ -35,12 +37,21 @@ pub fn resolve_environment(
         // Now try to resolve this fully, by spawning python.
         if let Some(ref executable) = env.executable {
             if let Some(info) = ResolvedPythonEnv::from(executable) {
+                trace!(
+                    "In resolve_environment, Resolved Python Exe {:?} as {:?}",
+                    executable,
+                    info
+                );
                 let discovered = env.clone();
                 let mut resolved = env.clone();
                 let mut symlinks = resolved.symlinks.clone().unwrap_or_default();
 
                 symlinks.push(info.executable.clone());
                 symlinks.append(&mut info.symlink.clone().unwrap_or_default());
+                symlinks.sort();
+                symlinks.dedup();
+
+                resolved.symlinks = Some(symlinks);
                 resolved.version = Some(info.version);
                 resolved.prefix = Some(info.prefix);
                 resolved.arch = Some(if info.is64_bit {

crates/pet/tests/ci_jupyter_container.rs

@@ -1,8 +1,21 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+use std::sync::Once;
+
 mod common;
 
+static INIT: Once = Once::new();
+
+/// Setup function that is only run once, even if called multiple times.
+fn setup() {
+    INIT.call_once(|| {
+        env_logger::builder()
+            .filter(None, log::LevelFilter::Trace)
+            .init();
+    });
+}
+
 #[cfg(unix)]
 #[cfg_attr(feature = "ci-jupyter-container", test)]
 #[allow(dead_code)]
@@ -19,6 +32,8 @@ fn verify_python_in_jupyter_contaner() {
     use pet_reporter::test;
     use std::{path::PathBuf, sync::Arc};
 
+    setup();
+
     let reporter = test::create_reporter();
     let environment = EnvironmentApi::new();
     let conda_locator = Arc::new(Conda::from(&environment));
@@ -121,23 +136,53 @@ fn verify_python_in_jupyter_contaner() {
             .iter()
             .find(|e| e.executable == env.executable)
             .expect(format!("Expected to find python environment {:?}", env.executable).as_str());
-        assert_eq!(python_env.executable, env.executable);
-        assert_eq!(python_env.category, env.category);
-        assert_eq!(python_env.symlinks, env.symlinks);
-        assert_eq!(python_env.manager, env.manager);
-        assert_eq!(python_env.name, env.name);
-        assert_eq!(python_env.version, env.version);
-        assert_eq!(python_env.arch, env.arch);
+        assert_eq!(
+            python_env.executable, env.executable,
+            "Expected exe to be same when comparing {:?} and {:?}",
+            python_env, env
+        );
+        assert_eq!(
+            python_env.category, env.category,
+            "Expected category to be same when comparing {:?} and {:?}",
+            python_env, env
+        );
+        assert_eq!(
+            python_env.symlinks, env.symlinks,
+            "Expected symlinks to be same when comparing {:?} and {:?}",
+            python_env, env
+        );
+        assert_eq!(
+            python_env.manager, env.manager,
+            "Expected manager to be same when comparing {:?} and {:?}",
+            python_env, env
+        );
+        assert_eq!(
+            python_env.name, env.name,
+            "Expected name to be same when comparing {:?} and {:?}",
+            python_env, env
+        );
+        assert_eq!(
+            python_env.version, env.version,
+            "Expected version to be same when comparing {:?} and {:?}",
+            python_env, env
+        );
+        assert_eq!(
+            python_env.arch, env.arch,
+            "Expected arch to be same when comparing {:?} and {:?}",
+            python_env, env
+        );
 
         // known issue https://github.com/microsoft/python-environment-tools/issues/64
         if env.executable == Some(PathBuf::from("/home/codespace/.python/current/bin/python")) {
             assert!(
                 python_env.prefix == Some(PathBuf::from("/home/codespace/.python/current"))
                     || python_env.prefix == Some(PathBuf::from("/usr/local/python/3.10.13")),
-                "Expected {:?} to be {:?} or {:?}",
+                "Expected {:?} to be {:?} or {:?} when comparing {:?} and {:?}",
                 python_env.prefix,
                 "/home/codespace/.python/current",
-                "/usr/local/python/3.10.13"
+                "/usr/local/python/3.10.13",
+                python_env,
+                env
             );
         }
     }

crates/pet/tests/ci_test.rs

@@ -96,22 +96,19 @@ fn verify_validity_of_discovered_envs() {
         threads.push(thread::spawn(move || {
             verify_validity_of_interpreter_info(e);
         }));
-        // Verification 2:
-        // For each enviornment, given the executable verify we can get the exact same information
-        // Using the `locator.try_from` method (without having to find all environments).
-        // I.e. we should be able to get the same information using only the executable.
-        //
-        // Verification 3:
-        // Similarly for each environment use one of the known symlinks and verify we can get the same information.
-        //
-        // TODO: Verification 4 & 5:
-        // Similarly for each environment use resolve method and verify we get the exact same information.
         let e = environment.clone();
         threads.push(thread::spawn(move || {
             for exe in &e.clone().symlinks.unwrap_or_default() {
-                // Verification 2 & 3.
+                // Verification 2:
+                // For each enviornment, given the executable verify we can get the exact same information
+                // Using the `locator.try_from` method (without having to find all environments).
+                // I.e. we should be able to get the same information using only the executable.
+                //
+                // Verification 3:
+                // Similarly for each environment use one of the known symlinks and verify we can get the same information.
                 verify_we_can_get_same_env_info_using_from_with_exe(exe, environment.clone());
-                // Verification 4 & 5.
+                // Verification 4 & 5:
+                // Similarly for each environment use resolve method and verify we get the exact same information.
                 // verify_we_can_get_same_env_info_using_resolve_with_exe(exe, environment.clone());
             }
         }));

todo.md

@@ -0,0 +1,71 @@
+# Support for
+
+- PIPENV_MAX_DEPTH
+
+# VirutalenvWrapper
+
+- `find` is implemented
+  Why? Ensure this same logic is implemented in the global lcoators
+  Besides this logic might be wrong, as we might be marking `pipenv` as a `virtualenvwrapper` as a aresult of this logic.
+
+
+# Priority
+
+- Need to ship => List envs and compare against Python extension (compare exe & type) & send telemetry
+- Resolve
+- Cache
+
+* List all exes in the following bin dir
+/home/linuxbrew/.linuxbrew/Cellar/[email protected]/3.12.4/bin/python3.12
+
+# Pyenv manager not reported if there are no pyenv environments.
+
+# Sometimes users have .venv files and `python` folders,
+
+Ensure we take this into account.
+
+# Ensure we handle searching folders with 10000s of files
+
+# Mac test
+
+- Write tests for CI, to ensure there are no mac global python where the executable does not point to anytihng in `framework.python...`
+  The executable must be something in `/usr/local/bin/python?`
+- Only one of the Mac-global python shoudl have two symlinks pointing to `/Library/Frameworks/Python.framework/Versions/Current/bin/python3?` exes
+
+# Optimizations
+
+- Avoid using `to_path` when using `read_dir`, where possible filter early
+- Avoid reading metadata, try using `PathBuf.is_file...` etc where possible.
+- Avoid checking if a file/dir exists, instead just open/read_dir and fail (thats one less I/O operation)
+
+# Add `isWorkspaceLocator` to the Locator trait
+
+This way we can create the locators in one place and re-use the list.
+
+# Add CLI flag to wait for `conda_locator.find_with_conda_executable(conda_executable);` to complete so we can see if we missed anything
+
+# Add CLI flag to print just summary, not everything, useful for debugging and see counts
+
+# Add CLI flag to dump everything into a JSON file, useful for debugging and diagnostics
+
+# Add CLI flag to resolve everything
+
+# We need to handle the following scenarios
+
+- Install commandline tools in mac
+  /usr/bin/python3 points to that python env (/Library/Developer/CommandLineTools/usr/bin/python3)
+
+- We cache this
+  We have an env with /usr/bin/python3 and symlinks as /Library/Developer/CommandLineTools/usr/bin/python3
+
+- Install X Code
+  /usr/bin/python3 now points to another python env.
+  /Applications/Xcode.app/Contents/Developer/usr/bin/python3
+
+- Now when reading the cache, the executable `/usr/bin/python3`
+  Does not point to the same place.
+  Fortunately it doesn't work, as none of the locators directly support `/usr/bin/python3`
+  We should
+- Ensure the ctime and mtime of the main exe is captured
+- Then when validating, check if that has changed, if not then continue with the validation.
+- If it has changed, then skip validation, and let the usual locator code handle it.